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

package/cjs/utils/inputValidation/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateEvaluationOptions = exports.validateTrafficTypeExistence = exports.validateSplitExistence = exports.validateIfOperational = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateSplits = exports.validateSplit = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
+exports.validateEvaluationOptions = exports.validateTrafficTypeExistence = exports.validateSplitExistence = exports.validateIfOperational = exports.validateIfReadyFromCache = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateSplits = exports.validateSplit = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
 var apiKey_1 = require("./apiKey");
 Object.defineProperty(exports, "validateApiKey", { enumerable: true, get: function () { return apiKey_1.validateApiKey; } });
 Object.defineProperty(exports, "validateAndTrackApiKey", { enumerable: true, get: function () { return apiKey_1.validateAndTrackApiKey; } });
@@ -23,6 +23,7 @@ var trafficType_1 = require("./trafficType");
 Object.defineProperty(exports, "validateTrafficType", { enumerable: true, get: function () { return trafficType_1.validateTrafficType; } });
 var isOperational_1 = require("./isOperational");
 Object.defineProperty(exports, "validateIfNotDestroyed", { enumerable: true, get: function () { return isOperational_1.validateIfNotDestroyed; } });
+Object.defineProperty(exports, "validateIfReadyFromCache", { enumerable: true, get: function () { return isOperational_1.validateIfReadyFromCache; } });
 Object.defineProperty(exports, "validateIfOperational", { enumerable: true, get: function () { return isOperational_1.validateIfOperational; } });
 var splitExistence_1 = require("./splitExistence");
 Object.defineProperty(exports, "validateSplitExistence", { enumerable: true, get: function () { return splitExistence_1.validateSplitExistence; } });

package/cjs/utils/inputValidation/isOperational.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateIfOperational = exports.validateIfNotDestroyed = void 0;
+exports.validateIfOperational = exports.validateIfReadyFromCache = exports.validateIfNotDestroyed = void 0;
 var constants_1 = require("../../logger/constants");
 function validateIfNotDestroyed(log, readinessManager, method) {
     if (!readinessManager.isDestroyed())
@@ -9,10 +9,15 @@ function validateIfNotDestroyed(log, readinessManager, method) {
     return false;
 }
 exports.validateIfNotDestroyed = validateIfNotDestroyed;
-function validateIfOperational(log, readinessManager, method, featureFlagNameOrNames) {
-    if (readinessManager.isReady() || readinessManager.isReadyFromCache())
+function validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames) {
+    if (readinessManager.isReadyFromCache())
         return true;
-    log.warn(constants_1.CLIENT_NOT_READY, [method, featureFlagNameOrNames ? " for feature flag " + featureFlagNameOrNames.toString() : '']);
+    log.warn(constants_1.CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? " for feature flag " + featureFlagNameOrNames.toString() : '']);
     return false;
 }
+exports.validateIfReadyFromCache = validateIfReadyFromCache;
+// Operational means that the SDK is ready to evaluate (not destroyed and ready from cache)
+function validateIfOperational(log, readinessManager, method, featureFlagNameOrNames) {
+    return validateIfNotDestroyed(log, readinessManager, method) && validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames);
+}
 exports.validateIfOperational = validateIfOperational;

package/cjs/utils/inputValidation/splitExistence.js

@@ -5,11 +5,11 @@ var labels_1 = require("../labels");
 var constants_1 = require("../../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.
  */
 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 === labels_1.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 === labels_1.SPLIT_NOT_FOUND || labelOrSplitObj === labels_1.FALLBACK_SPLIT_NOT_FOUND || labelOrSplitObj == null) {
             log.warn(constants_1.WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
             return false;
         }

package/cjs/utils/labels/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PREREQUISITES_NOT_MET = exports.UNSUPPORTED_MATCHER_TYPE = exports.NOT_IN_SPLIT = exports.SPLIT_ARCHIVED = exports.EXCEPTION = exports.SDK_NOT_READY = exports.SPLIT_NOT_FOUND = exports.NO_CONDITION_MATCH = exports.SPLIT_KILLED = void 0;
+exports.FALLBACK_SPLIT_NOT_FOUND = exports.PREREQUISITES_NOT_MET = exports.UNSUPPORTED_MATCHER_TYPE = exports.NOT_IN_SPLIT = exports.SPLIT_ARCHIVED = exports.EXCEPTION = exports.SDK_NOT_READY = exports.SPLIT_NOT_FOUND = exports.NO_CONDITION_MATCH = exports.SPLIT_KILLED = void 0;
+var fallbackTreatmentsCalculator_1 = require("../../evaluator/fallbackTreatmentsCalculator");
 exports.SPLIT_KILLED = 'killed';
 exports.NO_CONDITION_MATCH = 'default rule';
 exports.SPLIT_NOT_FOUND = 'definition not found';
@@ -10,3 +11,4 @@ exports.SPLIT_ARCHIVED = 'archived';
 exports.NOT_IN_SPLIT = 'not in split';
 exports.UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';
 exports.PREREQUISITES_NOT_MET = 'prerequisites not met';
+exports.FALLBACK_SPLIT_NOT_FOUND = fallbackTreatmentsCalculator_1.FALLBACK_PREFIX + exports.SPLIT_NOT_FOUND;

package/esm/evaluator/fallbackTreatmentsCalculator/constants.js

@@ -0,0 +1,5 @@
+export var FallbackDiscardReason;
+(function (FallbackDiscardReason) {
+    FallbackDiscardReason["FlagName"] = "Invalid flag name (max 100 chars, no spaces)";
+    FallbackDiscardReason["Treatment"] = "Invalid treatment (max 100 chars and must match pattern)";
+})(FallbackDiscardReason || (FallbackDiscardReason = {}));

package/esm/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.js

@@ -0,0 +1,44 @@
+import { isObject, isString } from '../../../utils/lang';
+import { FallbackDiscardReason } from '../constants';
+var FallbacksSanitizer = /** @class */ (function () {
+    function FallbacksSanitizer() {
+    }
+    FallbacksSanitizer.isValidFlagName = function (name) {
+        return name.length <= 100 && !name.includes(' ');
+    };
+    FallbacksSanitizer.isValidTreatment = function (t) {
+        var treatment = isObject(t) ? t.treatment : t;
+        if (!isString(treatment) || treatment.length > 100) {
+            return false;
+        }
+        return FallbacksSanitizer.pattern.test(treatment);
+    };
+    FallbacksSanitizer.sanitizeGlobal = function (logger, treatment) {
+        if (!this.isValidTreatment(treatment)) {
+            logger.error("Fallback treatments - Discarded fallback: " + FallbackDiscardReason.Treatment);
+            return undefined;
+        }
+        return treatment;
+    };
+    FallbacksSanitizer.sanitizeByFlag = function (logger, byFlagFallbacks) {
+        var _this = this;
+        var sanitizedByFlag = {};
+        var entries = Object.keys(byFlagFallbacks);
+        entries.forEach(function (flag) {
+            var 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;
+    };
+    FallbacksSanitizer.pattern = /^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$/;
+    return FallbacksSanitizer;
+}());
+export { FallbacksSanitizer };

package/esm/evaluator/fallbackTreatmentsCalculator/index.js

@@ -0,0 +1,45 @@
+import { FallbacksSanitizer } from './fallbackSanitizer';
+import { CONTROL } from '../../utils/constants';
+import { isString } from '../../utils/lang';
+export var FALLBACK_PREFIX = 'fallback - ';
+var FallbackTreatmentsCalculator = /** @class */ (function () {
+    function FallbackTreatmentsCalculator(logger, fallbacks) {
+        var sanitizedGlobal = (fallbacks === null || fallbacks === void 0 ? void 0 : fallbacks.global) ? FallbacksSanitizer.sanitizeGlobal(logger, fallbacks.global) : undefined;
+        var sanitizedByFlag = (fallbacks === null || fallbacks === void 0 ? void 0 : fallbacks.byFlag) ? FallbacksSanitizer.sanitizeByFlag(logger, fallbacks.byFlag) : {};
+        this.fallbacks = {
+            global: sanitizedGlobal,
+            byFlag: sanitizedByFlag
+        };
+    }
+    FallbackTreatmentsCalculator.prototype.resolve = function (flagName, label) {
+        var _a;
+        var treatment = (_a = this.fallbacks.byFlag) === null || _a === void 0 ? void 0 : _a[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: label,
+        };
+    };
+    FallbackTreatmentsCalculator.prototype.copyWithLabel = function (fallback, label) {
+        if (isString(fallback)) {
+            return {
+                treatment: fallback,
+                config: null,
+                label: "" + FALLBACK_PREFIX + label,
+            };
+        }
+        return {
+            treatment: fallback.treatment,
+            config: fallback.config,
+            label: "" + FALLBACK_PREFIX + label,
+        };
+    };
+    return FallbackTreatmentsCalculator;
+}());
+export { FallbackTreatmentsCalculator };

package/esm/logger/constants.js

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

package/esm/logger/messages/info.js

@@ -19,7 +19,7 @@ export var codesInfo = 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/esm/logger/messages/warn.js

@@ -5,7 +5,7 @@ export var codesWarn = 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'],
@@ -13,8 +13,8 @@ export var codesWarn = 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/esm/readiness/readinessManager.js

@@ -1,6 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 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 { STORAGE_LOCALSTORAGE } from '../utils/constants';
 function splitsEventEmitterFactory(EventEmitter) {
     var splitsEventEmitter = objectAssign(new EventEmitter(), {
         splitsArrived: false,
@@ -72,7 +71,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         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
@@ -81,7 +80,6 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         }
     }
     function checkIsReadyOrUpdate(diff) {
-        var _a;
         if (isDestroyed)
             return;
         if (isReady) {
@@ -100,9 +98,9 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
                 isReady = true;
                 try {
                     syncLastUpdate();
-                    if (!isReadyFromCache && ((_a = settings.storage) === null || _a === void 0 ? void 0 : _a.type) === STORAGE_LOCALSTORAGE) {
+                    if (!isReadyFromCache) {
                         isReadyFromCache = true;
-                        gate.emit(SDK_READY_FROM_CACHE);
+                        gate.emit(SDK_READY_FROM_CACHE, isReady);
                     }
                     gate.emit(SDK_READY);
                 }

package/esm/readiness/sdkReadinessManager.js

@@ -5,6 +5,7 @@ import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from
 import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
 var NEW_LISTENER_EVENT = 'newListener';
 var REMOVE_LISTENER_EVENT = 'removeListener';
+var 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).
  * It also updates logs related warnings and errors.
@@ -31,6 +32,9 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
                 readyCbCount++;
             }
         }
+        else if (event === SDK_READY_FROM_CACHE && readinessManager.isReadyFromCache()) {
+            log.error(ERROR_CLIENT_LISTENER, ['SDK_READY_FROM_CACHE']);
+        }
     });
     /** Ready promise */
     var readyPromise = generateReadyPromise();
@@ -73,6 +77,7 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
                 SDK_UPDATE: SDK_UPDATE,
                 SDK_READY_TIMED_OUT: SDK_READY_TIMED_OUT,
             },
+            // @TODO: remove in next major
             ready: function () {
                 if (readinessManager.hasTimedout()) {
                     if (!readinessManager.isReady()) {
@@ -84,6 +89,34 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
                 }
                 return readyPromise;
             },
+            whenReady: function () {
+                return new Promise(function (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, function () { return reject(TIMEOUT_ERROR); });
+                    }
+                });
+            },
+            whenReadyFromCache: function () {
+                return new Promise(function (resolve, reject) {
+                    if (readinessManager.isReadyFromCache()) {
+                        resolve(readinessManager.isReady());
+                    }
+                    else if (readinessManager.hasTimedout()) {
+                        reject(TIMEOUT_ERROR);
+                    }
+                    else {
+                        readinessManager.gate.once(SDK_READY_FROM_CACHE, function () { return resolve(readinessManager.isReady()); });
+                        readinessManager.gate.once(SDK_READY_TIMED_OUT, function () { return reject(TIMEOUT_ERROR); });
+                    }
+                });
+            },
             __getStatus: function () {
                 return {
                     isReady: readinessManager.isReady(),

package/esm/sdkClient/client.js

@@ -27,7 +27,7 @@ function stringify(options) {
  * Creator of base client with getTreatments and track methods.
  */
 export function clientFactory(params) {
-    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker, telemetryTracker = params.telemetryTracker;
+    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker, telemetryTracker = params.telemetryTracker, fallbackTreatmentsCalculator = params.fallbackTreatmentsCalculator;
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     function getTreatment(key, featureFlagName, attributes, options, withConfig, methodName) {
@@ -41,7 +41,7 @@ export function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatment;
         };
-        var evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+        var 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) :
@@ -66,7 +66,7 @@ export function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatments;
         };
-        var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+        var 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)) :
@@ -92,7 +92,7 @@ export function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatments;
         };
-        var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+        var evaluations = readinessManager.isReadyFromCache() ?
             evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
             isAsync ?
                 Promise.resolve({}) :
@@ -112,7 +112,14 @@ export function clientFactory(params) {
     function processEvaluation(evaluation, featureFlagName, key, properties, withConfig, invokingMethodName, queue) {
         var matchingKey = getMatching(key);
         var bucketingKey = getBucketing(key);
-        var treatment = evaluation.treatment, label = evaluation.label, changeNumber = evaluation.changeNumber, _a = evaluation.config, config = _a === void 0 ? null : _a, impressionsDisabled = evaluation.impressionsDisabled;
+        var changeNumber = evaluation.changeNumber, impressionsDisabled = evaluation.impressionsDisabled;
+        var treatment = evaluation.treatment, label = evaluation.label, _a = evaluation.config, config = _a === void 0 ? null : _a;
+        if (treatment === CONTROL) {
+            var 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)) {
             log.info(IMPRESSION_QUEUEING);

package/esm/sdkClient/clientInputValidation.js

@@ -1,14 +1,13 @@
-import { objectAssign } from '../utils/lang/objectAssign';
-import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational, validateEvaluationOptions } from '../utils/inputValidation';
+import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, 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 { isConsumerMode } from '../utils/settingsValidation/mode';
 import { validateFlagSets } from '../utils/settingsValidation/splitFilters';
 /**
  * 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(settings, client, readinessManager) {
+export function clientInputValidationDecorator(settings, client, readinessManager, fallbackTreatmentsCalculator) {
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     /**
@@ -24,7 +23,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         var attributes = validateAttributes(log, maybeAttributes, methodName);
         var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
         var options = validateEvaluationOptions(log, maybeOptions, methodName);
-        validateIfOperational(log, readinessManager, methodName, nameOrNames);
+        validateIfReadyFromCache(log, readinessManager, methodName, nameOrNames);
         var valid = isNotDestroyed && key && nameOrNames && attributes !== false;
         return {
             valid: valid,
@@ -34,6 +33,16 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             options: options
         };
     }
+    function evaluateFallBackTreatment(featureFlagName, withConfig) {
+        var _a = fallbackTreatmentsCalculator.resolve(featureFlagName, ''), treatment = _a.treatment, config = _a.config;
+        if (withConfig) {
+            return {
+                treatment: treatment,
+                config: config
+            };
+        }
+        return treatment;
+    }
     function wrapResult(value) {
         return isAsync ? Promise.resolve(value) : value;
     }
@@ -43,7 +52,8 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             return client.getTreatment(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
-            return wrapResult(CONTROL);
+            var result = evaluateFallBackTreatment(params.nameOrNames, false);
+            return wrapResult(result);
         }
     }
     function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
@@ -52,7 +62,8 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             return client.getTreatmentWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
-            return wrapResult(objectAssign({}, CONTROL_WITH_CONFIG));
+            var result = evaluateFallBackTreatment(params.nameOrNames, true);
+            return wrapResult(result);
         }
     }
     function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
@@ -63,7 +74,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         else {
             var res_1 = {};
             if (params.nameOrNames)
-                params.nameOrNames.forEach(function (split) { return res_1[split] = CONTROL; });
+                params.nameOrNames.forEach(function (split) { return res_1[split] = evaluateFallBackTreatment(split, false); });
             return wrapResult(res_1);
         }
     }
@@ -75,7 +86,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         else {
             var res_2 = {};
             if (params.nameOrNames)
-                params.nameOrNames.forEach(function (split) { return res_2[split] = objectAssign({}, CONTROL_WITH_CONFIG); });
+                params.nameOrNames.forEach(function (split) { return res_2[split] = evaluateFallBackTreatment(split, true); });
             return wrapResult(res_2);
         }
     }

package/esm/sdkClient/sdkClient.js

@@ -32,7 +32,7 @@ export function sdkClientFactory(params, isSharedClient) {
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
     // Client API (getTreatment* & track methods)
-    clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager), 
+    clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager, params.fallbackTreatmentsCalculator), 
     // Sdk destroy
     {
         flush: function () {

package/esm/sdkFactory/index.js

@@ -14,6 +14,7 @@ import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
 import { DEBUG, OPTIMIZED } from '../utils/constants';
 import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { getMatching } from '../utils/key';
+import { FallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCalculator';
 /**
  * Modular SDK factory
  */
@@ -48,6 +49,7 @@ export function sdkFactory(params) {
             readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
         }
     });
+    var fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.log, settings.fallbackTreatments);
     if (initialRolloutPlan) {
         setRolloutPlan(log, initialRolloutPlan, storage, key && getMatching(key));
         if (storage.splits.getChangeNumber() > -1)
@@ -68,7 +70,7 @@ export function sdkFactory(params) {
     var eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
+    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, fallbackTreatmentsCalculator: fallbackTreatmentsCalculator };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);

package/esm/sdkManager/index.js

@@ -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 { isConsumerMode } from '../utils/settingsValidation/mode';
 import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
 function collectTreatments(splitObject) {
@@ -51,7 +51,7 @@ export function sdkManagerFactory(settings, splits, _a) {
          */
         split: function (featureFlagName) {
             var 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;
             }
             var split = splits.getSplit(splitName);
@@ -68,7 +68,7 @@ export function sdkManagerFactory(settings, splits, _a) {
          * Get the feature flag objects present on the factory storage
          */
         splits: function () {
-            if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
+            if (!validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
                 return isAsync ? Promise.resolve([]) : [];
             }
             var currentSplits = splits.getAll();
@@ -80,7 +80,7 @@ export function sdkManagerFactory(settings, splits, _a) {
          * Get the feature flag names present on the factory storage
          */
         names: function () {
-            if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
+            if (!validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
                 return isAsync ? Promise.resolve([]) : [];
             }
             var splitNames = splits.getSplitNames();

package/esm/sync/polling/syncTasks/segmentsSyncTask.js

@@ -5,5 +5,5 @@ import { segmentChangesUpdaterFactory } from '../updaters/segmentChangesUpdater'
  * Creates a sync task that periodically executes a `segmentChangesUpdater` task
  */
 export function segmentsSyncTaskFactory(fetchSegmentChanges, storage, readiness, settings) {
-    return syncTaskFactory(settings.log, segmentChangesUpdaterFactory(settings.log, segmentChangesFetcherFactory(fetchSegmentChanges), storage.segments, readiness, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
+    return syncTaskFactory(settings.log, segmentChangesUpdaterFactory(settings.log, segmentChangesFetcherFactory(fetchSegmentChanges), storage.segments, readiness), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
 }

package/esm/sync/polling/updaters/segmentChangesUpdater.js

@@ -1,6 +1,5 @@
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
-import { timeout } from '../../../utils/promise/timeout';
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -12,33 +11,22 @@ import { timeout } from '../../../utils/promise/timeout';
  * @param segments - segments storage, with sync or async methods
  * @param readiness - optional readiness manager. Not required for synchronizer or producer mode.
  */
-export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness, requestTimeoutBeforeReady, retriesOnFailureBeforeReady) {
+export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness) {
     var readyOnAlreadyExistentState = true;
-    function _promiseDecorator(promise) {
-        if (readyOnAlreadyExistentState && requestTimeoutBeforeReady)
-            promise = timeout(requestTimeoutBeforeReady, promise);
-        return promise;
-    }
-    function updateSegment(segmentName, noCache, till, fetchOnlyNew, retries) {
+    function updateSegment(segmentName, noCache, till, fetchOnlyNew) {
         log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing segment " + segmentName);
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
             return fetchOnlyNew && since !== undefined ?
                 false :
-                segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then(function (changes) {
+                segmentChangesFetcher(since || -1, segmentName, noCache, till).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
                         log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
                         return segments.update(segmentName, x.added, x.removed, x.till);
                     })).then(function (updates) {
                         return updates.some(function (update) { return update; });
                     });
-                }).catch(function (error) {
-                    if (retries) {
-                        log.warn(LOG_PREFIX_SYNC_SEGMENTS + "Retrying fetch of segment " + segmentName + " (attempt #" + retries + "). Reason: " + error);
-                        return updateSegment(segmentName, noCache, till, fetchOnlyNew, retries - 1);
-                    }
-                    throw error;
                 });
         });
     }
@@ -58,7 +46,8 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
         // If not a segment name provided, read list of available segments names to be updated.
         var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
-            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew, readyOnAlreadyExistentState ? retriesOnFailureBeforeReady : 0); });
+            // Async fetchers
+            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew); });
             return Promise.all(updaters).then(function (shouldUpdateFlags) {
                 // if at least one segment fetch succeeded, mark segments ready
                 if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -166,14 +166,14 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, sp
                 });
             })
                 .catch(function (error) {
+                log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
                 if (startingUp && retriesOnFailureBeforeReady > retry) {
                     retry += 1;
-                    log.warn(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
+                    log.info(SYNC_SPLITS_FETCH_RETRY, [retry, error]);
                     return _splitChangesUpdater(sinces, retry);
                 }
                 else {
                     startingUp = false;
-                    log.warn(SYNC_SPLITS_FETCH_FAILS, [error]);
                 }
                 return false;
             });

package/esm/sync/streaming/SSEHandler/index.js

@@ -16,7 +16,7 @@ export function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
             // Ably error
             var code = error.parsedData.code;
             telemetryTracker.streamingEvent(ABLY_ERROR, code);
-            // 401 errors due to invalid or expired token (e.g., if refresh token coudn't be executed)
+            // 401 errors due to invalid or expired token (e.g., if refresh token couldn't be executed)
             if (40140 <= code && code <= 40149)
                 return true;
             // Others 4XX errors (e.g., bad request from the SDK)

package/esm/sync/submitters/telemetrySubmitter.js

@@ -102,14 +102,14 @@ export function telemetrySubmitterFactory(params) {
     if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
     var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
-    var startTime = timer(now);
+    var stopTimer = timer(now);
     var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
-        telemetry.recordTimeUntilReadyFromCache(startTime());
+        telemetry.recordTimeUntilReadyFromCache(stopTimer());
     });
     sdkReadinessManager.incInternalReadyCbCount();
     readiness.gate.once(SDK_READY, function () {
-        telemetry.recordTimeUntilReady(startTime());
+        telemetry.recordTimeUntilReady(stopTimer());
         // Post config data when the SDK is ready and if the telemetry submitter was started
         if (submitter.isRunning()) {
             var postMetricsConfigTask = submitterFactory(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);