@splitsoftware/splitio-commons 2.7.2-rc.0 → 2.7.9-rc.1

package/esm/trackers/telemetryTracker.js

@@ -3,10 +3,10 @@ import { timer } from '../utils/timeTracker/timer';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../utils/constants';
 export function telemetryTrackerFactory(telemetryCache, now) {
     if (telemetryCache && now) {
-        var startTime_1 = timer(now);
+        var sessionTimer_1 = timer(now);
         return {
             trackEval: function (method) {
-                var evalTime = timer(now);
+                var evalTimer = timer(now);
                 return function (label) {
                     switch (label) {
                         case EXCEPTION:
@@ -16,13 +16,13 @@ export function telemetryTrackerFactory(telemetryCache, now) {
                             if (telemetryCache.recordNonReadyUsage)
                                 telemetryCache.recordNonReadyUsage();
                     }
-                    telemetryCache.recordLatency(method, evalTime());
+                    telemetryCache.recordLatency(method, evalTimer());
                 };
             },
             trackHttp: function (operation) {
-                var httpTime = timer(now);
+                var httpTimer = timer(now);
                 return function (error) {
-                    telemetryCache.recordHttpLatency(operation, httpTime());
+                    telemetryCache.recordHttpLatency(operation, httpTimer());
                     if (error && error.statusCode)
                         telemetryCache.recordHttpError(operation, error.statusCode);
                     else
@@ -31,7 +31,7 @@ export function telemetryTrackerFactory(telemetryCache, now) {
             },
             sessionLength: function () {
                 if (telemetryCache.recordSessionLength)
-                    telemetryCache.recordSessionLength(startTime_1());
+                    telemetryCache.recordSessionLength(sessionTimer_1());
             },
             streamingEvent: function (e, d) {
                 if (e === AUTH_REJECTION) {

package/esm/utils/inputValidation/index.js

@@ -7,7 +7,7 @@ export { validateKey } from './key';
 export { validateSplit } from './split';
 export { validateSplits } from './splits';
 export { validateTrafficType } from './trafficType';
-export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
+export { validateIfNotDestroyed, validateIfReadyFromCache, validateIfOperational } from './isOperational';
 export { validateSplitExistence } from './splitExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validateEvaluationOptions } from './eventProperties';

package/esm/utils/inputValidation/isOperational.js

@@ -1,13 +1,17 @@
-import { ERROR_CLIENT_DESTROYED, CLIENT_NOT_READY } from '../../logger/constants';
+import { ERROR_CLIENT_DESTROYED, CLIENT_NOT_READY_FROM_CACHE } from '../../logger/constants';
 export function validateIfNotDestroyed(log, readinessManager, method) {
     if (!readinessManager.isDestroyed())
         return true;
     log.error(ERROR_CLIENT_DESTROYED, [method]);
     return false;
 }
-export function validateIfOperational(log, readinessManager, method, featureFlagNameOrNames) {
-    if (readinessManager.isReady() || readinessManager.isReadyFromCache())
+export function validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames) {
+    if (readinessManager.isReadyFromCache())
         return true;
-    log.warn(CLIENT_NOT_READY, [method, featureFlagNameOrNames ? " for feature flag " + featureFlagNameOrNames.toString() : '']);
+    log.warn(CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? " for feature flag " + featureFlagNameOrNames.toString() : '']);
     return false;
 }
+// Operational means that the SDK is ready to evaluate (not destroyed and ready from cache)
+export function validateIfOperational(log, readinessManager, method, featureFlagNameOrNames) {
+    return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames);
+}

package/esm/utils/inputValidation/splitExistence.js

@@ -1,12 +1,12 @@
-import { SPLIT_NOT_FOUND } from '../labels';
+import { FALLBACK_SPLIT_NOT_FOUND, SPLIT_NOT_FOUND } from '../labels';
 import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
 /**
  * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
- * But it's not going to run on the input validation layer. In any case, the most compeling reason to use it as we do is to avoid going to Redis and get a split twice.
+ * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a split twice.
  */
 export function validateSplitExistence(log, readinessManager, splitName, labelOrSplitObj, method) {
-    if (readinessManager.isReady()) { // Only if it's ready we validate this, otherwise it may just be that the SDK is not ready yet.
-        if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj == null) {
+    if (readinessManager.isReady()) { // Only if it's ready (synced with BE) we validate this, otherwise it may just be that the SDK is still syncing
+        if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj === FALLBACK_SPLIT_NOT_FOUND || labelOrSplitObj == null) {
             log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
             return false;
         }

package/esm/utils/labels/index.js

@@ -1,3 +1,4 @@
+import { FALLBACK_PREFIX } from '../../evaluator/fallbackTreatmentsCalculator';
 export var SPLIT_KILLED = 'killed';
 export var NO_CONDITION_MATCH = 'default rule';
 export var SPLIT_NOT_FOUND = 'definition not found';
@@ -7,3 +8,4 @@ export var SPLIT_ARCHIVED = 'archived';
 export var NOT_IN_SPLIT = 'not in split';
 export var UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';
 export var PREREQUISITES_NOT_MET = 'prerequisites not met';
+export var FALLBACK_SPLIT_NOT_FOUND = FALLBACK_PREFIX + SPLIT_NOT_FOUND;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.7.2-rc.0",
+  "version": "2.7.9-rc.1",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/evaluator/fallbackTreatmentsCalculator/constants.ts

@@ -0,0 +1,4 @@
+export enum FallbackDiscardReason {
+  FlagName = 'Invalid flag name (max 100 chars, no spaces)',
+  Treatment = 'Invalid treatment (max 100 chars and must match pattern)',
+}

package/src/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.ts

@@ -0,0 +1,62 @@
+import { Treatment, TreatmentWithConfig } from '../../../../types/splitio';
+import { ILogger } from '../../../logger/types';
+import { isObject, isString } from '../../../utils/lang';
+import { FallbackDiscardReason } from '../constants';
+
+
+export class FallbacksSanitizer {
+
+  private static readonly pattern = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
+
+  private static isValidFlagName(name: string): boolean {
+    return name.length <= 100 && !name.includes(' ');
+  }
+
+  private static isValidTreatment(t?: Treatment | TreatmentWithConfig): boolean {
+    const treatment = isObject(t) ? (t as TreatmentWithConfig).treatment : t;
+
+    if (!isString(treatment) || treatment.length > 100) {
+      return false;
+    }
+    return FallbacksSanitizer.pattern.test(treatment);
+  }
+
+  static sanitizeGlobal(logger: ILogger, treatment?: Treatment | TreatmentWithConfig): Treatment | TreatmentWithConfig | undefined {
+    if (!this.isValidTreatment(treatment)) {
+      logger.error(
+        `Fallback treatments - Discarded fallback: ${FallbackDiscardReason.Treatment}`
+      );
+      return undefined;
+    }
+    return treatment;
+  }
+
+  static sanitizeByFlag(
+    logger: ILogger,
+    byFlagFallbacks: Record<string, Treatment | TreatmentWithConfig>
+  ): Record<string, Treatment | TreatmentWithConfig> {
+    const sanitizedByFlag: Record<string, Treatment | TreatmentWithConfig> = {};
+
+    const entries = Object.keys(byFlagFallbacks);
+    entries.forEach((flag) => {
+      const t = byFlagFallbacks[flag];
+      if (!this.isValidFlagName(flag)) {
+        logger.error(
+          `Fallback treatments - Discarded flag '${flag}': ${FallbackDiscardReason.FlagName}`
+        );
+        return;
+      }
+
+      if (!this.isValidTreatment(t)) {
+        logger.error(
+          `Fallback treatments - Discarded treatment for flag '${flag}': ${FallbackDiscardReason.Treatment}`
+        );
+        return;
+      }
+
+      sanitizedByFlag[flag] = t;
+    });
+
+    return sanitizedByFlag;
+  }
+}

package/src/evaluator/fallbackTreatmentsCalculator/index.ts

@@ -0,0 +1,57 @@
+import { FallbackTreatmentConfiguration, Treatment, TreatmentWithConfig } from '../../../types/splitio';
+import { FallbacksSanitizer } from './fallbackSanitizer';
+import { CONTROL } from '../../utils/constants';
+import { isString } from '../../utils/lang';
+import { ILogger } from '../../logger/types';
+
+export type IFallbackTreatmentsCalculator = {
+  resolve(flagName: string, label: string): TreatmentWithConfig & { label: string };
+}
+
+export const FALLBACK_PREFIX = 'fallback - ';
+
+export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculator {
+  private readonly fallbacks: FallbackTreatmentConfiguration;
+
+  constructor(logger: ILogger, fallbacks?: FallbackTreatmentConfiguration) {
+    const sanitizedGlobal = fallbacks?.global ? FallbacksSanitizer.sanitizeGlobal(logger, fallbacks.global) : undefined;
+    const sanitizedByFlag = fallbacks?.byFlag ? FallbacksSanitizer.sanitizeByFlag(logger, fallbacks.byFlag) : {};
+    this.fallbacks = {
+      global: sanitizedGlobal,
+      byFlag: sanitizedByFlag
+    };
+  }
+
+  resolve(flagName: string, label: string): TreatmentWithConfig & { label: string } {
+    const treatment = this.fallbacks.byFlag?.[flagName];
+    if (treatment) {
+      return this.copyWithLabel(treatment, label);
+    }
+
+    if (this.fallbacks.global) {
+      return this.copyWithLabel(this.fallbacks.global, label);
+    }
+
+    return {
+      treatment: CONTROL,
+      config: null,
+      label,
+    };
+  }
+
+  private copyWithLabel(fallback: Treatment | TreatmentWithConfig, label: string): TreatmentWithConfig & { label: string } {
+    if (isString(fallback)) {
+      return {
+        treatment: fallback,
+        config: null,
+        label: `${FALLBACK_PREFIX}${label}`,
+      };
+    }
+
+    return {
+      treatment: fallback.treatment,
+      config: fallback.config,
+      label: `${FALLBACK_PREFIX}${label}`,
+    };
+  }
+}

package/src/logger/constants.ts

@@ -60,7 +60,7 @@ export const SUBMITTERS_PUSH_PAGE_HIDDEN = 125;
 export const ENGINE_VALUE_INVALID = 200;
 export const ENGINE_VALUE_NO_ATTRIBUTES = 201;
 export const CLIENT_NO_LISTENER = 202;
-export const CLIENT_NOT_READY = 203;
+export const CLIENT_NOT_READY_FROM_CACHE = 203;
 export const SYNC_MYSEGMENTS_FETCH_RETRY = 204;
 export const SYNC_SPLITS_FETCH_FAILS = 205;
 export const STREAMING_PARSING_ERROR_FAILS = 206;

package/src/logger/messages/info.ts

@@ -22,7 +22,7 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],
   [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
   [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
-  [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying fetch of feature flags (attempt #%s). Reason: %s'],
+  [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of feature flags #%s. Reason: %s'],
   [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and resetting timer.'],
   [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
   [c.SUBMITTERS_PUSH_PAGE_HIDDEN, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing %s because page became hidden.'],

package/src/logger/messages/warn.ts

@@ -6,7 +6,7 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.ENGINE_VALUE_INVALID, c.LOG_PREFIX_ENGINE_VALUE + 'Value %s doesn\'t match with expected type.'],
   [c.ENGINE_VALUE_NO_ATTRIBUTES, c.LOG_PREFIX_ENGINE_VALUE + 'Defined attribute `%s`. No attributes received.'],
   // synchronizer
-  [c.SYNC_MYSEGMENTS_FETCH_RETRY, c.LOG_PREFIX_SYNC_MYSEGMENTS + 'Retrying fetch of memberships (attempt #%s). Reason: %s'],
+  [c.SYNC_MYSEGMENTS_FETCH_RETRY, c.LOG_PREFIX_SYNC_MYSEGMENTS + 'Retrying download of segments #%s. Reason: %s'],
   [c.SYNC_SPLITS_FETCH_FAILS, c.LOG_PREFIX_SYNC_SPLITS + 'Error while doing fetch of feature flags. %s'],
   [c.STREAMING_PARSING_ERROR_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE error notification: %s'],
   [c.STREAMING_PARSING_MESSAGE_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE message notification: %s'],
@@ -14,8 +14,8 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.SUBMITTERS_PUSH_FAILS, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Dropping %s after retry. Reason: %s.'],
   [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s, keeping data to retry on next iteration. Reason: %s.'],
   // client status
-  [c.CLIENT_NOT_READY, '%s: the SDK is not ready, results may be incorrect%s. Make sure to wait for SDK readiness before using this method.'],
-  [c.CLIENT_NO_LISTENER, 'No listeners for SDK Readiness detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet ready.'],
+  [c.CLIENT_NOT_READY_FROM_CACHE, '%s: the SDK is not ready to evaluate. Results may be incorrect%s. Make sure to wait for SDK readiness before using this method.'],
+  [c.CLIENT_NO_LISTENER, 'No listeners for SDK_READY event detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet synchronized with the backend.'],
   // input validation
   [c.WARN_SETTING_NULL, '%s: Property "%s" is of invalid type. Setting value to null.'],
   [c.WARN_TRIMMING_PROPERTIES, '%s: more than 300 properties were provided. Some of them will be trimmed when processed.'],

package/src/readiness/readinessManager.ts

@@ -3,7 +3,6 @@ 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(), {
@@ -91,7 +90,7 @@ export function readinessManagerFactory(
     if (!isReady && !isDestroyed) {
       try {
         syncLastUpdate();
-        gate.emit(SDK_READY_FROM_CACHE);
+        gate.emit(SDK_READY_FROM_CACHE, isReady);
       } catch (e) {
         // throws user callback exceptions in next tick
         setTimeout(() => { throw e; }, 0);
@@ -115,9 +114,9 @@ export function readinessManagerFactory(
         isReady = true;
         try {
           syncLastUpdate();
-          if (!isReadyFromCache && settings.storage?.type === STORAGE_LOCALSTORAGE) {
+          if (!isReadyFromCache) {
             isReadyFromCache = true;
-            gate.emit(SDK_READY_FROM_CACHE);
+            gate.emit(SDK_READY_FROM_CACHE, isReady);
           }
           gate.emit(SDK_READY);
         } catch (e) {

package/src/readiness/sdkReadinessManager.ts

@@ -9,6 +9,7 @@ import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO
 
 const NEW_LISTENER_EVENT = 'newListener';
 const REMOVE_LISTENER_EVENT = 'removeListener';
+const TIMEOUT_ERROR = new Error(SDK_READY_TIMED_OUT);
 
 /**
  * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
@@ -38,6 +39,8 @@ export function sdkReadinessManagerFactory(
       } else if (event === SDK_READY) {
         readyCbCount++;
       }
+    } else if (event === SDK_READY_FROM_CACHE && readinessManager.isReadyFromCache()) {
+      log.error(ERROR_CLIENT_LISTENER, ['SDK_READY_FROM_CACHE']);
     }
   });
 
@@ -93,6 +96,7 @@ export function sdkReadinessManagerFactory(
           SDK_READY_TIMED_OUT,
         },
 
+        // @TODO: remove in next major
         ready() {
           if (readinessManager.hasTimedout()) {
             if (!readinessManager.isReady()) {
@@ -104,6 +108,32 @@ export function sdkReadinessManagerFactory(
           return readyPromise;
         },
 
+        whenReady() {
+          return new Promise<void>((resolve, reject) => {
+            if (readinessManager.isReady()) {
+              resolve();
+            } else if (readinessManager.hasTimedout()) {
+              reject(TIMEOUT_ERROR);
+            } else {
+              readinessManager.gate.once(SDK_READY, resolve);
+              readinessManager.gate.once(SDK_READY_TIMED_OUT, () => reject(TIMEOUT_ERROR));
+            }
+          });
+        },
+
+        whenReadyFromCache() {
+          return new Promise<boolean>((resolve, reject) => {
+            if (readinessManager.isReadyFromCache()) {
+              resolve(readinessManager.isReady());
+            } else if (readinessManager.hasTimedout()) {
+              reject(TIMEOUT_ERROR);
+            } else {
+              readinessManager.gate.once(SDK_READY_FROM_CACHE, () => resolve(readinessManager.isReady()));
+              readinessManager.gate.once(SDK_READY_TIMED_OUT, () => reject(TIMEOUT_ERROR));
+            }
+          });
+        },
+
         __getStatus() {
           return {
             isReady: readinessManager.isReady(),

package/src/sdkClient/client.ts

@@ -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 } = params;
+  const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker, telemetryTracker, fallbackTreatmentsCalculator } = params;
   const { log, mode } = settings;
   const isAsync = isConsumerMode(mode);
 
@@ -51,7 +51,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatment;
     };
 
-    const evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+    const evaluation = 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) :
@@ -80,7 +80,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatments;
     };
 
-    const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+    const evaluations = 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)) :
@@ -109,7 +109,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatments;
     };
 
-    const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+    const evaluations = readinessManager.isReadyFromCache() ?
       evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
       isAsync ?
         Promise.resolve({}) :
@@ -143,7 +143,16 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     const matchingKey = getMatching(key);
     const bucketingKey = getBucketing(key);
 
-    const { treatment, label, changeNumber, config = null, impressionsDisabled } = evaluation;
+    const { changeNumber, impressionsDisabled } = evaluation;
+    let { treatment, label, config = null } = evaluation;
+
+    if (treatment === CONTROL) {
+      const fallbackTreatment = fallbackTreatmentsCalculator.resolve(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)) {

package/src/sdkClient/clientInputValidation.ts

@@ -1,4 +1,3 @@
-import { objectAssign } from '../utils/lang/objectAssign';
 import {
   validateAttributes,
   validateEvent,
@@ -9,23 +8,24 @@ import {
   validateSplits,
   validateTrafficType,
   validateIfNotDestroyed,
-  validateIfOperational,
+  validateIfReadyFromCache,
   validateEvaluationOptions
 } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
-import { CONTROL, CONTROL_WITH_CONFIG, 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, TRACK_FN_LABEL } 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';
 
 /**
  * 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): TClient {
+export function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager, fallbackTreatmentsCalculator: IFallbackTreatmentsCalculator): TClient {
 
   const { log, mode } = settings;
   const isAsync = isConsumerMode(mode);
@@ -46,7 +46,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
     const options = validateEvaluationOptions(log, maybeOptions, methodName);
 
-    validateIfOperational(log, readinessManager, methodName, nameOrNames);
+    validateIfReadyFromCache(log, readinessManager, methodName, nameOrNames);
 
     const valid = isNotDestroyed && key && nameOrNames && attributes !== false;
 
@@ -59,6 +59,19 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     };
   }
 
+  function evaluateFallBackTreatment(featureFlagName: string, withConfig: boolean): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
+    const { treatment, config } = fallbackTreatmentsCalculator.resolve(featureFlagName, '');
+
+    if (withConfig) {
+      return {
+        treatment,
+        config
+      };
+    }
+
+    return treatment;
+  }
+
   function wrapResult<T>(value: T): MaybeThenable<T> {
     return isAsync ? Promise.resolve(value) : value;
   }
@@ -69,7 +82,8 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     if (params.valid) {
       return client.getTreatment(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options);
     } else {
-      return wrapResult(CONTROL);
+      const result = evaluateFallBackTreatment(params.nameOrNames as string, false);
+      return wrapResult(result);
     }
   }
 
@@ -79,7 +93,8 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     if (params.valid) {
       return client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.nameOrNames as string, params.attributes as SplitIO.Attributes | undefined, params.options);
     } else {
-      return wrapResult(objectAssign({}, CONTROL_WITH_CONFIG));
+      const result = evaluateFallBackTreatment(params.nameOrNames as string, true);
+      return wrapResult(result);
     }
   }
 
@@ -90,7 +105,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
       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] = CONTROL);
+      if (params.nameOrNames) (params.nameOrNames as string[]).forEach((split: string) => res[split] = evaluateFallBackTreatment(split, false) as SplitIO.Treatment);
 
       return wrapResult(res);
     }
@@ -103,7 +118,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
       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] = objectAssign({}, CONTROL_WITH_CONFIG));
+      if (params.nameOrNames) (params.nameOrNames as string[]).forEach(split => res[split] = evaluateFallBackTreatment(split, true) as SplitIO.TreatmentWithConfig);
 
       return wrapResult(res);
     }

package/src/sdkClient/sdkClient.ts

@@ -43,7 +43,8 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
     clientInputValidationDecorator(
       settings,
       clientFactory(params),
-      sdkReadinessManager.readinessManager
+      sdkReadinessManager.readinessManager,
+      params.fallbackTreatmentsCalculator
     ),
 
     // Sdk destroy

package/src/sdkFactory/index.ts

@@ -17,6 +17,7 @@ import { DEBUG, OPTIMIZED } from '../utils/constants';
 import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { IStorageSync } from '../storages/types';
 import { getMatching } from '../utils/key';
+import { FallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCalculator';
 
 /**
  * Modular SDK factory
@@ -60,6 +61,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     }
   });
 
+  const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.log, settings.fallbackTreatments);
+
   if (initialRolloutPlan) {
     setRolloutPlan(log, initialRolloutPlan, storage as IStorageSync, key && getMatching(key));
     if ((storage as IStorageSync).splits.getChangeNumber() > -1) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
@@ -85,7 +88,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
+  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform, fallbackTreatmentsCalculator };
 
   const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
   ctx.syncManager = syncManager;

package/src/sdkFactory/types.ts

@@ -3,6 +3,7 @@ import { ISignalListener } from '../listeners/types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
 import type { sdkManagerFactory } from '../sdkManager';
 import type { splitApiFactory } from '../services/splitApi';
+import type { IFallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCalculator';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
@@ -51,6 +52,7 @@ export interface ISdkFactoryContext {
   splitApi?: ISplitApi
   syncManager?: ISyncManager,
   clients: Record<string, SplitIO.IBasicClient>,
+  fallbackTreatmentsCalculator: IFallbackTreatmentsCalculator
 }
 
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {

package/src/sdkManager/index.ts

@@ -1,7 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
-import { validateSplit, validateSplitExistence, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
+import { validateSplit, validateSplitExistence, validateIfOperational } from '../utils/inputValidation';
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISplit } from '../dtos/types';
@@ -66,7 +66,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        */
       split(featureFlagName: string) {
         const splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
-        if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
+        if (!validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
           return isAsync ? Promise.resolve(null) : null;
         }
 
@@ -87,7 +87,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        * Get the feature flag objects present on the factory storage
        */
       splits() {
-        if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
+        if (!validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
           return isAsync ? Promise.resolve([]) : [];
         }
         const currentSplits = splits.getAll();
@@ -100,7 +100,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        * Get the feature flag names present on the factory storage
        */
       names() {
-        if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
+        if (!validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
           return isAsync ? Promise.resolve([]) : [];
         }
         const splitNames = splits.getSplitNames();

package/src/sync/polling/syncTasks/segmentsSyncTask.ts

@@ -23,8 +23,6 @@ export function segmentsSyncTaskFactory(
       segmentChangesFetcherFactory(fetchSegmentChanges),
       storage.segments,
       readiness,
-      settings.startup.requestTimeoutBeforeReady,
-      settings.startup.retriesOnFailureBeforeReady,
     ),
     settings.scheduler.segmentsRefreshRate,
     'segmentChangesUpdater'