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

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/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/utils/inputValidation/splitExistence.js

@@ -1,4 +1,4 @@
-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.
@@ -6,7 +6,7 @@ import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
  */
 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 (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj == null || labelOrSplitObj === FALLBACK_SPLIT_NOT_FOUND) {
             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.0",
   "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/index.ts

@@ -72,6 +72,8 @@ export class Logger implements ILogger {
     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 {
         this.error('Invalid `logger` instance. It must be an object with `debug`, `info`, `warn` and `error` methods. Defaulting to `console.log`');

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

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);
 
@@ -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 ? fallbackTreatment.label : 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,
@@ -13,19 +12,20 @@ import {
   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);
@@ -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/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'

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -4,7 +4,6 @@ import { IReadinessManager } from '../../../readiness/types';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
-import { timeout } from '../../../utils/promise/timeout';
 
 type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>
 
@@ -24,18 +23,11 @@ export function segmentChangesUpdaterFactory(
   segmentChangesFetcher: ISegmentChangesFetcher,
   segments: ISegmentsCacheBase,
   readiness?: IReadinessManager,
-  requestTimeoutBeforeReady?: number,
-  retriesOnFailureBeforeReady?: number,
 ): ISegmentChangesUpdater {
 
   let readyOnAlreadyExistentState = true;
 
-  function _promiseDecorator<T>(promise: Promise<T>) {
-    if (readyOnAlreadyExistentState && requestTimeoutBeforeReady) promise = timeout(requestTimeoutBeforeReady, promise);
-    return promise;
-  }
-
-  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean, retries?: number): Promise<boolean> {
+  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean): Promise<boolean> {
     log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
     let sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
 
@@ -43,19 +35,13 @@ export function segmentChangesUpdaterFactory(
       // if fetchOnlyNew flag, avoid processing already fetched segments
       return fetchOnlyNew && since !== undefined ?
         false :
-        segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then((changes) => {
+        segmentChangesFetcher(since || -1, segmentName, noCache, till).then((changes) => {
           return Promise.all(changes.map(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((updates) => {
             return updates.some(update => update);
           });
-        }).catch(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;
         });
     });
   }
@@ -77,7 +63,8 @@ export function segmentChangesUpdaterFactory(
     let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
 
     return segmentsPromise.then(segmentNames => {
-      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew, readyOnAlreadyExistentState ? retriesOnFailureBeforeReady : 0));
+      // Async fetchers
+      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew));
 
       return Promise.all(updaters).then(shouldUpdateFlags => {
         // if at least one segment fetch succeeded, mark segments ready

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -120,8 +120,8 @@ export function splitChangesUpdaterFactory(
   storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments' | 'save'>,
   splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
-  requestTimeoutBeforeReady = 0,
-  retriesOnFailureBeforeReady = 0,
+  requestTimeoutBeforeReady: number = 0,
+  retriesOnFailureBeforeReady: number = 0,
   isClientSide?: boolean
 ): SplitChangesUpdater {
   const { splits, rbSegments, segments } = storage;
@@ -201,13 +201,14 @@ export function splitChangesUpdaterFactory(
           });
         })
         .catch(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/src/utils/inputValidation/splitExistence.ts

@@ -1,4 +1,4 @@
-import { SPLIT_NOT_FOUND } from '../labels';
+import { FALLBACK_SPLIT_NOT_FOUND, SPLIT_NOT_FOUND } from '../labels';
 import { IReadinessManager } from '../../readiness/types';
 import { ILogger } from '../../logger/types';
 import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
@@ -9,7 +9,7 @@ import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
  */
 export function validateSplitExistence(log: ILogger, readinessManager: IReadinessManager, splitName: string, labelOrSplitObj: any, method: string): boolean {
   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 (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj == null || labelOrSplitObj === FALLBACK_SPLIT_NOT_FOUND) {
       log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
       return false;
     }

package/src/utils/labels/index.ts

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

package/types/splitio.d.ts

@@ -93,7 +93,6 @@ interface ISharedSettings {
   urls?: SplitIO.UrlSettings;
   /**
    * Custom logger object. If not provided, the SDK will use the default `console.log` method for all log levels.
-   * Set together with `debug` option to `true` or a log level string to enable logging.
    */
   logger?: SplitIO.Logger;
 }
@@ -146,6 +145,8 @@ interface IPluggableSharedSettings {
    * config.debug = ErrorLogger()
    * ```
    *
+   * When combined with the `logger` option, any log level other than `NONE` (false) will be set to `DEBUG` (true), delegating log level control to the custom logger.
+   *
    * @defaultValue `false`
    */
   debug?: boolean | SplitIO.LogLevel | SplitIO.ILogger;
@@ -169,6 +170,8 @@ interface INonPluggableSharedSettings {
    * config.debug = 'WARN'
    * ```
    *
+   * When combined with the `logger` option, any log level other than `NONE` (false) will be set to `DEBUG` (true), delegating log level control to the custom logger.
+   *
    * @defaultValue `false`
    */
   debug?: boolean | SplitIO.LogLevel;
@@ -618,6 +621,10 @@ declare namespace SplitIO {
      * User consent status if using in client-side. Undefined if using in server-side (Node.js).
      */
     readonly userConsent?: ConsentStatus;
+    /**
+     * Fallback treatments to be used when the SDK is not ready or the flag is not found.
+     */
+    readonly fallbackTreatments?: FallbackTreatmentConfiguration;
   }
   /**
    * Log levels.
@@ -1225,6 +1232,15 @@ declare namespace SplitIO {
    * User consent status.
    */
   type ConsentStatus = 'GRANTED' | 'DECLINED' | 'UNKNOWN';
+  /**
+   * Fallback treatments to be used when the SDK is not ready or the flag is not found.
+   */
+  type FallbackTreatmentConfiguration = {
+    global?: Treatment | TreatmentWithConfig,
+    byFlag?: {
+      [featureFlagName: string]: Treatment | TreatmentWithConfig
+    }
+  }
   /**
    * Logger. Its interface details are not part of the public API. It shouldn't be used directly.
    */