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

package/CHANGES.txt

@@ -1,11 +1,8 @@
 2.8.0 (October XX, 2025)
- - Updated the SDK’s initial synchronization in Node.js (server-side) to use `startup.requestTimeoutBeforeReady` and `startup.retriesOnFailureBeforeReady` to control the timeout and retry behavior of segment requests.
-
-2.7.1 (October 8, 2025)
- - Bugfix - Update `debug` option to support log levels when `logger` option is used.
+  - Added new configuration for Fallback Treatments, which allows setting a treatment value and optional config to be returned in place of "control", either globally or by flag. Read more in our docs.
 
 2.7.0 (October 7, 2025)
- - Added support for custom loggers: added `logger` configuration option and `factory.Logger.setLogger` method to allow the SDK to use a custom logger.
+ - Added support for custom loggers: added `logger` configuration option and `LoggerAPI.setLogger` method to allow the SDK to use a custom logger.
 
 2.6.0 (September 18, 2025)
  - Added `storage.wrapper` configuration option to allow the SDK to use a custom storage wrapper for the storage type `LOCALSTORAGE`. Default value is `window.localStorage`.

package/cjs/evaluator/fallbackTreatmentsCalculator/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackDiscardReason = void 0;
+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 = exports.FallbackDiscardReason || (exports.FallbackDiscardReason = {}));

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbacksSanitizer = void 0;
+var lang_1 = require("../../../utils/lang");
+var constants_1 = require("../constants");
+var FallbacksSanitizer = /** @class */ (function () {
+    function FallbacksSanitizer() {
+    }
+    FallbacksSanitizer.isValidFlagName = function (name) {
+        return name.length <= 100 && !name.includes(' ');
+    };
+    FallbacksSanitizer.isValidTreatment = function (t) {
+        var treatment = (0, lang_1.isObject)(t) ? t.treatment : t;
+        if (!(0, lang_1.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: " + constants_1.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 + "': " + constants_1.FallbackDiscardReason.FlagName);
+                return;
+            }
+            if (!_this.isValidTreatment(t)) {
+                logger.error("Fallback treatments - Discarded treatment for flag '" + flag + "': " + constants_1.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;
+}());
+exports.FallbacksSanitizer = FallbacksSanitizer;

package/cjs/evaluator/fallbackTreatmentsCalculator/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackTreatmentsCalculator = exports.FALLBACK_PREFIX = void 0;
+var fallbackSanitizer_1 = require("./fallbackSanitizer");
+var constants_1 = require("../../utils/constants");
+var lang_1 = require("../../utils/lang");
+exports.FALLBACK_PREFIX = 'fallback - ';
+var FallbackTreatmentsCalculator = /** @class */ (function () {
+    function FallbackTreatmentsCalculator(logger, fallbacks) {
+        var sanitizedGlobal = (fallbacks === null || fallbacks === void 0 ? void 0 : fallbacks.global) ? fallbackSanitizer_1.FallbacksSanitizer.sanitizeGlobal(logger, fallbacks.global) : undefined;
+        var sanitizedByFlag = (fallbacks === null || fallbacks === void 0 ? void 0 : fallbacks.byFlag) ? fallbackSanitizer_1.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: constants_1.CONTROL,
+            config: null,
+            label: label,
+        };
+    };
+    FallbackTreatmentsCalculator.prototype.copyWithLabel = function (fallback, label) {
+        if ((0, lang_1.isString)(fallback)) {
+            return {
+                treatment: fallback,
+                config: null,
+                label: "" + exports.FALLBACK_PREFIX + label,
+            };
+        }
+        return {
+            treatment: fallback.treatment,
+            config: fallback.config,
+            label: "" + exports.FALLBACK_PREFIX + label,
+        };
+    };
+    return FallbackTreatmentsCalculator;
+}());
+exports.FallbackTreatmentsCalculator = FallbackTreatmentsCalculator;

package/cjs/logger/index.js

@@ -63,6 +63,9 @@ var Logger = /** @class */ (function () {
         if (logger) {
             if ((0, commons_1.isLogger)(logger)) {
                 this.logger = logger;
+                // If custom logger is set, all logs are either enabled or disabled
+                if (this.logLevel !== LogLevelIndexes.NONE)
+                    this.setLogLevel(exports.LogLevels.DEBUG);
                 return;
             }
             else {

package/cjs/logger/messages/info.js

@@ -23,7 +23,7 @@ exports.codesInfo = warn_1.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/cjs/logger/messages/warn.js

@@ -9,7 +9,7 @@ exports.codesWarn = error_1.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'],

package/cjs/sdkClient/client.js

@@ -30,7 +30,7 @@ function stringify(options) {
  * Creator of base client with getTreatments and track methods.
  */
 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 = (0, mode_1.isConsumerMode)(mode);
     function getTreatment(key, featureFlagName, attributes, options, withConfig, methodName) {
@@ -115,7 +115,14 @@ function clientFactory(params) {
     function processEvaluation(evaluation, featureFlagName, key, properties, withConfig, invokingMethodName, queue) {
         var matchingKey = (0, key_1.getMatching)(key);
         var bucketingKey = (0, key_1.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 === constants_1.CONTROL) {
+            var fallbackTreatment = fallbackTreatmentsCalculator.resolve(featureFlagName, label);
+            treatment = fallbackTreatment.treatment;
+            label = fallbackTreatment.label ? fallbackTreatment.label : label;
+            config = fallbackTreatment.config;
+        }
         log.info(constants_2.IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
         if ((0, splitExistence_1.validateSplitExistence)(log, readinessManager, featureFlagName, label, invokingMethodName)) {
             log.info(constants_2.IMPRESSION_QUEUEING);

package/cjs/sdkClient/clientInputValidation.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clientInputValidationDecorator = void 0;
-var objectAssign_1 = require("../utils/lang/objectAssign");
 var inputValidation_1 = require("../utils/inputValidation");
 var lang_1 = require("../utils/lang");
 var constants_1 = require("../utils/constants");
@@ -11,7 +10,7 @@ var splitFilters_1 = require("../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.
  */
-function clientInputValidationDecorator(settings, client, readinessManager) {
+function clientInputValidationDecorator(settings, client, readinessManager, fallbackTreatmentsCalculator) {
     var log = settings.log, mode = settings.mode;
     var isAsync = (0, mode_1.isConsumerMode)(mode);
     /**
@@ -37,6 +36,16 @@ function clientInputValidationDecorator(settings, client, readinessManager) {
             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;
     }
@@ -46,7 +55,8 @@ function clientInputValidationDecorator(settings, client, readinessManager) {
             return client.getTreatment(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
-            return wrapResult(constants_1.CONTROL);
+            var result = evaluateFallBackTreatment(params.nameOrNames, false);
+            return wrapResult(result);
         }
     }
     function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
@@ -55,7 +65,8 @@ function clientInputValidationDecorator(settings, client, readinessManager) {
             return client.getTreatmentWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
-            return wrapResult((0, objectAssign_1.objectAssign)({}, constants_1.CONTROL_WITH_CONFIG));
+            var result = evaluateFallBackTreatment(params.nameOrNames, true);
+            return wrapResult(result);
         }
     }
     function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
@@ -66,7 +77,7 @@ function clientInputValidationDecorator(settings, client, readinessManager) {
         else {
             var res_1 = {};
             if (params.nameOrNames)
-                params.nameOrNames.forEach(function (split) { return res_1[split] = constants_1.CONTROL; });
+                params.nameOrNames.forEach(function (split) { return res_1[split] = evaluateFallBackTreatment(split, false); });
             return wrapResult(res_1);
         }
     }
@@ -78,7 +89,7 @@ function clientInputValidationDecorator(settings, client, readinessManager) {
         else {
             var res_2 = {};
             if (params.nameOrNames)
-                params.nameOrNames.forEach(function (split) { return res_2[split] = (0, objectAssign_1.objectAssign)({}, constants_1.CONTROL_WITH_CONFIG); });
+                params.nameOrNames.forEach(function (split) { return res_2[split] = evaluateFallBackTreatment(split, true); });
             return wrapResult(res_2);
         }
     }

package/cjs/sdkClient/sdkClient.js

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

package/cjs/sdkFactory/index.js

@@ -17,6 +17,7 @@ var uniqueKeysTracker_1 = require("../trackers/uniqueKeysTracker");
 var constants_3 = require("../utils/constants");
 var setRolloutPlan_1 = require("../storages/setRolloutPlan");
 var key_1 = require("../utils/key");
+var fallbackTreatmentsCalculator_1 = require("../evaluator/fallbackTreatmentsCalculator");
 /**
  * Modular SDK factory
  */
@@ -51,6 +52,7 @@ function sdkFactory(params) {
             readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
         }
     });
+    var fallbackTreatmentsCalculator = new fallbackTreatmentsCalculator_1.FallbackTreatmentsCalculator(settings.log, settings.fallbackTreatments);
     if (initialRolloutPlan) {
         (0, setRolloutPlan_1.setRolloutPlan)(log, initialRolloutPlan, storage, key && (0, key_1.getMatching)(key));
         if (storage.splits.getChangeNumber() > -1)
@@ -71,7 +73,7 @@ function sdkFactory(params) {
     var eventTracker = (0, eventTracker_1.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/cjs/sync/polling/syncTasks/segmentsSyncTask.js

@@ -8,6 +8,6 @@ var segmentChangesUpdater_1 = require("../updaters/segmentChangesUpdater");
  * Creates a sync task that periodically executes a `segmentChangesUpdater` task
  */
 function segmentsSyncTaskFactory(fetchSegmentChanges, storage, readiness, settings) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, segmentChangesUpdater_1.segmentChangesUpdaterFactory)(settings.log, (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(fetchSegmentChanges), storage.segments, readiness, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, segmentChangesUpdater_1.segmentChangesUpdaterFactory)(settings.log, (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(fetchSegmentChanges), storage.segments, readiness), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
 }
 exports.segmentsSyncTaskFactory = segmentsSyncTaskFactory;

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.segmentChangesUpdaterFactory = void 0;
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
-var timeout_1 = require("../../../utils/promise/timeout");
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -15,33 +14,22 @@ var timeout_1 = require("../../../utils/promise/timeout");
  * @param segments - segments storage, with sync or async methods
  * @param readiness - optional readiness manager. Not required for synchronizer or producer mode.
  */
-function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness, requestTimeoutBeforeReady, retriesOnFailureBeforeReady) {
+function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness) {
     var readyOnAlreadyExistentState = true;
-    function _promiseDecorator(promise) {
-        if (readyOnAlreadyExistentState && requestTimeoutBeforeReady)
-            promise = (0, timeout_1.timeout)(requestTimeoutBeforeReady, promise);
-        return promise;
-    }
-    function updateSegment(segmentName, noCache, till, fetchOnlyNew, retries) {
+    function updateSegment(segmentName, noCache, till, fetchOnlyNew) {
         log.debug(constants_2.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(constants_2.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(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Retrying fetch of segment " + segmentName + " (attempt #" + retries + "). Reason: " + error);
-                        return updateSegment(segmentName, noCache, till, fetchOnlyNew, retries - 1);
-                    }
-                    throw error;
                 });
         });
     }
@@ -61,7 +49,8 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
         // 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/cjs/sync/polling/updaters/splitChangesUpdater.js

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

package/cjs/utils/inputValidation/splitExistence.js

@@ -9,7 +9,7 @@ var constants_1 = require("../../logger/constants");
  */
 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 (labelOrSplitObj === labels_1.SPLIT_NOT_FOUND || labelOrSplitObj == null || labelOrSplitObj === labels_1.FALLBACK_SPLIT_NOT_FOUND) {
             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/index.js

@@ -58,6 +58,9 @@ var Logger = /** @class */ (function () {
         if (logger) {
             if (isLogger(logger)) {
                 this.logger = logger;
+                // If custom logger is set, all logs are either enabled or disabled
+                if (this.logLevel !== LogLevelIndexes.NONE)
+                    this.setLogLevel(LogLevels.DEBUG);
                 return;
             }
             else {

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'],

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) {
@@ -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 ? fallbackTreatment.label : 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 { 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);
     /**
@@ -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 () {