@splitsoftware/splitio-commons 1.12.1-rc.3 → 1.12.1-rc.5

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -3,6 +3,7 @@ import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSyn
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { _Set, setToArray } from '../../utils/lang/sets';
+import { getStorageHash } from '../KeyBuilder';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
@@ -13,13 +14,12 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
      * @param {number | undefined} expirationTimestamp
      * @param {ISplitFiltersValidation} splitFiltersValidation
      */
-    function SplitsCacheInLocal(log, keys, expirationTimestamp, splitFiltersValidation) {
-        if (splitFiltersValidation === void 0) { splitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }; }
+    function SplitsCacheInLocal(settings, keys, expirationTimestamp) {
         var _this = _super.call(this) || this;
-        _this.log = log;
         _this.keys = keys;
-        _this.splitFiltersValidation = splitFiltersValidation;
-        _this.flagSetsFilter = _this.splitFiltersValidation.groupedFilters.bySet;
+        _this.log = settings.log;
+        _this.storageHash = getStorageHash(settings);
+        _this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
         _this._checkExpiration(expirationTimestamp);
         _this._checkFilterQuery();
         return _this;
@@ -123,14 +123,10 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         // when using a new split query, we must update it at the store
         if (this.updateNewFilter) {
-            this.log.info(LOG_PREFIX + 'Split filter query was modified. Updating cache.');
-            var queryKey = this.keys.buildSplitsFilterQueryKey();
-            var queryString = this.splitFiltersValidation.queryString;
+            this.log.info(LOG_PREFIX + 'SDK key or feature flag filter criteria was modified. Updating cache.');
+            var storageHashKey = this.keys.buildHashKey();
             try {
-                if (queryString)
-                    localStorage.setItem(queryKey, queryString);
-                else
-                    localStorage.removeItem(queryKey);
+                localStorage.setItem(storageHashKey, this.storageHash);
             }
             catch (e) {
                 this.log.error(LOG_PREFIX + e);
@@ -208,11 +204,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 this.clear();
         }
     };
+    // @TODO eventually remove `_checkFilterQuery`. Cache should be cleared at the storage level, reusing same logic than PluggableStorage
     SplitsCacheInLocal.prototype._checkFilterQuery = function () {
-        var queryString = this.splitFiltersValidation.queryString;
-        var queryKey = this.keys.buildSplitsFilterQueryKey();
-        var currentQueryString = localStorage.getItem(queryKey);
-        if (currentQueryString !== queryString) {
+        var storageHashKey = this.keys.buildHashKey();
+        var storageHash = localStorage.getItem(storageHashKey);
+        if (storageHash !== this.storageHash) {
             try {
                 // mark cache to update the new query filter on first successful splits fetch
                 this.updateNewFilter = true;

package/esm/storages/inLocalStorage/index.js

@@ -31,7 +31,7 @@ export function InLocalStorage(options) {
         var matchingKey = getMatching(settings.core.key);
         var keys = new KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-        var splits = new SplitsCacheInLocal(log, keys, expirationTimestamp, __splitFiltersValidation);
+        var splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal(log, keys);
         return {
             splits: splits,

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -2,7 +2,7 @@ import { __extends, __spreadArray } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { _Set, returnListDifference } from '../../utils/lang/sets';
+import { _Set, returnDifference } from '../../utils/lang/sets';
 /**
  * Discard errors for an answer of multiple operations.
  */
@@ -49,8 +49,8 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     };
     SplitsCacheInRedis.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
         var _this = this;
-        var removeFromFlagSets = returnListDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
-        var addToFlagSets = returnListDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
+        var removeFromFlagSets = returnDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
+        var addToFlagSets = returnDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
         if (this.flagSetsFilter.length > 0) {
             addToFlagSets = addToFlagSets.filter(function (flagSet) {
                 return _this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === flagSet; });

package/esm/storages/inRedis/index.js

@@ -36,7 +36,7 @@ export function InRedisStorage(options) {
             telemetry.recordConfig();
         });
         return {
-            splits: new SplitsCacheInRedis(log, keys, redisClient),
+            splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
             segments: new SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
             impressionCounts: impressionCountsCache,

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -2,7 +2,7 @@ import { __extends, __spreadArray } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { _Set, returnListDifference } from '../../utils/lang/sets';
+import { _Set, returnDifference } from '../../utils/lang/sets';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
  */
@@ -36,8 +36,8 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
     };
     SplitsCachePluggable.prototype._updateFlagSets = function (featureFlagName, flagSetsOfRemovedFlag, flagSetsOfAddedFlag) {
         var _this = this;
-        var removeFromFlagSets = returnListDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
-        var addToFlagSets = returnListDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
+        var removeFromFlagSets = returnDifference(flagSetsOfRemovedFlag, flagSetsOfAddedFlag);
+        var addToFlagSets = returnDifference(flagSetsOfAddedFlag, flagSetsOfRemovedFlag);
         if (this.flagSetsFilter.length > 0) {
             addToFlagSets = addToFlagSets.filter(function (flagSet) {
                 return _this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === flagSet; });

package/esm/storages/pluggable/index.js

@@ -6,7 +6,7 @@ import { ImpressionsCachePluggable } from './ImpressionsCachePluggable';
 import { EventsCachePluggable } from './EventsCachePluggable';
 import { wrapperAdapter, METHODS_TO_PROMISE_WRAP } from './wrapperAdapter';
 import { isObject } from '../../utils/lang';
-import { validatePrefix } from '../KeyBuilder';
+import { getStorageHash, validatePrefix } from '../KeyBuilder';
 import { CONSUMER_PARTIAL_MODE, DEBUG, NONE, STORAGE_PLUGGABLE } from '../../utils/constants';
 import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
@@ -73,15 +73,26 @@ export function PluggableStorage(options) {
             undefined;
         // Connects to wrapper and emits SDK_READY event on main client
         var connectPromise = wrapper.connect().then(function () {
-            onReadyCb();
-            // Start periodic flush of async storages if not running synchronizer (producer mode)
-            if (!isSyncronizer) {
+            if (isSyncronizer) {
+                // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+                return wrapper.get(keys.buildHashKey()).then(function (hash) {
+                    var currentHash = getStorageHash(settings);
+                    if (hash !== currentHash) {
+                        return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
+                            return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
+                        }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
+                    }
+                }).then(onReadyCb);
+            }
+            else {
+                // Start periodic flush of async storages if not running synchronizer (producer mode)
                 if (impressionCountsCache && impressionCountsCache.start)
                     impressionCountsCache.start();
                 if (uniqueKeysCache && uniqueKeysCache.start)
                     uniqueKeysCache.start();
                 if (telemetry && telemetry.recordConfig)
                     telemetry.recordConfig();
+                onReadyCb();
             }
         }).catch(function (e) {
             e = e || new Error('Error connecting wrapper');

package/esm/trackers/eventTracker.js

@@ -2,7 +2,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
 import { CONSENT_DECLINED, DROPPED, QUEUED } from '../utils/constants';
-import { isStorageSync } from './impressionObserver/utils';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 /**
  * Event tracker stores events in cache and pass them to the integrations manager if provided.
  *
@@ -10,8 +10,8 @@ import { isStorageSync } from './impressionObserver/utils';
  * @param integrationsManager optional event handler used for integrations
  */
 export function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
-    var log = settings.log;
-    var isSync = isStorageSync(settings);
+    var log = settings.log, mode = settings.mode;
+    var isAsync = isConsumerMode(mode);
     function queueEventsCallback(eventData, tracked) {
         var eventTypeId = eventData.eventTypeId, trafficTypeName = eventData.trafficTypeName, key = eventData.key, value = eventData.value, timestamp = eventData.timestamp, properties = eventData.properties;
         // Logging every prop would be too much.
@@ -38,7 +38,7 @@ export function eventTrackerFactory(settings, eventsCache, integrationsManager,
     return {
         track: function (eventData, size) {
             if (settings.userConsent === CONSENT_DECLINED) {
-                return isSync ? false : Promise.resolve(false);
+                return isAsync ? Promise.resolve(false) : false;
             }
             var tracked = eventsCache.track(eventData, size);
             if (thenable(tracked)) {

package/esm/utils/constants/index.js

@@ -29,6 +29,20 @@ export var STORAGE_PLUGGABLE = 'PLUGGABLE';
 export var CONSENT_GRANTED = 'GRANTED'; // The user has granted consent for tracking events and impressions
 export var CONSENT_DECLINED = 'DECLINED'; // The user has declined consent for tracking events and impressions
 export var CONSENT_UNKNOWN = 'UNKNOWN'; // The user has neither granted nor declined consent for tracking events and impressions
+// Client method names
+export var GET_TREATMENT = 'getTreatment';
+export var GET_TREATMENTS = 'getTreatments';
+export var GET_TREATMENT_WITH_CONFIG = 'getTreatmentWithConfig';
+export var GET_TREATMENTS_WITH_CONFIG = 'getTreatmentsWithConfig';
+export var GET_TREATMENTS_BY_FLAG_SET = 'getTreatmentsByFlagSet';
+export var GET_TREATMENTS_BY_FLAG_SETS = 'getTreatmentsByFlagSets';
+export var GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET = 'getTreatmentsWithConfigByFlagSet';
+export var GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = 'getTreatmentsWithConfigByFlagSets';
+export var TRACK_FN_LABEL = 'track';
+// Manager method names
+export var SPLIT_FN_LABEL = 'split';
+export var SPLITS_FN_LABEL = 'splits';
+export var NAMES_FN_LABEL = 'names';
 // Telemetry
 export var QUEUED = 0;
 export var DROPPED = 1;

package/esm/utils/lang/sets.js

@@ -102,7 +102,7 @@ export function returnSetsUnion(set, set2) {
     });
     return result;
 }
-export function returnListDifference(list, list2) {
+export function returnDifference(list, list2) {
     if (list === void 0) { list = []; }
     if (list2 === void 0) { list2 = []; }
     var result = new _Set(list);

package/esm/utils/settingsValidation/index.js

@@ -1,5 +1,5 @@
 import { merge, get } from '../lang';
-import { mode } from './mode';
+import { validateMode } from './mode';
 import { validateSplitFilters } from './splitFilters';
 import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
@@ -123,7 +123,7 @@ export function settingsValidation(config, validationParams) {
     startup.eventsFirstPushWindow = fromSecondsToMillis(startup.eventsFirstPushWindow);
     // ensure a valid SDK mode
     // @ts-ignore, modify readonly prop
-    withDefaults.mode = mode(withDefaults.core.authorizationKey, withDefaults.mode);
+    withDefaults.mode = validateMode(withDefaults.core.authorizationKey, withDefaults.mode);
     // ensure a valid Storage based on mode defined.
     // @ts-ignore, modify readonly prop
     if (storage)

package/esm/utils/settingsValidation/mode.js

@@ -1,5 +1,5 @@
 import { LOCALHOST_MODE, STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../constants';
-export function mode(key, mode) {
+export function validateMode(key, mode) {
     // Leaving the comparison as is, in case we change the mode name but not the setting.
     if (key === 'localhost')
         return LOCALHOST_MODE;
@@ -7,3 +7,9 @@ export function mode(key, mode) {
         throw Error('Invalid mode provided');
     return mode;
 }
+/**
+ * Storage is async if mode is consumer or partial consumer
+ */
+export function isConsumerMode(mode) {
+    return CONSUMER_MODE === mode || CONSUMER_PARTIAL_MODE === mode;
+}

package/esm/utils/settingsValidation/splitFilters.js

@@ -1,8 +1,8 @@
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../constants';
 import { validateSplits } from '../inputValidation/splits';
-import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS, ERROR_SETS_FILTER_EXCLUSIVE, WARN_SPLITS_FILTER_LOWERCASE_SET, WARN_SPLITS_FILTER_INVALID_SET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
+import { WARN_SPLITS_FILTER_IGNORED, WARN_SPLITS_FILTER_EMPTY, WARN_SPLITS_FILTER_INVALID, SETTINGS_SPLITS_FILTER, LOG_PREFIX_SETTINGS, ERROR_SETS_FILTER_EXCLUSIVE, WARN_LOWERCASE_FLAGSET, WARN_INVALID_FLAGSET, WARN_FLAGSET_NOT_CONFIGURED } from '../../logger/constants';
 import { objectAssign } from '../lang/objectAssign';
 import { find, uniq } from '../lang';
+import { isConsumerMode } from './mode';
 // Split filters metadata.
 // Ordered according to their precedency when forming the filter query string: `&names=<values>&prefixes=<values>`
 var FILTERS_METADATA = [
@@ -45,7 +45,7 @@ function validateSplitFilter(log, type, values, maxLength) {
     var result = validateSplits(log, values, LOG_PREFIX_SETTINGS, type + " filter", type + " filter value");
     if (result) {
         if (type === 'bySet') {
-            result = sanitizeFlagSets(log, result);
+            result = sanitizeFlagSets(log, result, LOG_PREFIX_SETTINGS);
         }
         // check max length
         if (result.length > maxLength)
@@ -78,7 +78,7 @@ function queryStringBuilder(groupedFilters) {
     return queryParams.length > 0 ? '&' + queryParams.join('&') : null;
 }
 /**
- * Sanitizes set names list taking in account:
+ * Sanitizes set names list taking into account:
  *  - It should be lowercase
  *  - Must adhere the following regular expression /^[a-z0-9][_a-z0-9]{0,49}$/ that means
  *   - must start with a letter or number
@@ -88,20 +88,21 @@ function queryStringBuilder(groupedFilters) {
  *
  * @param {ILogger} log
  * @param {string[]} flagSets
+ * @param {string} method
  * @returns sanitized list of set names
  */
-function sanitizeFlagSets(log, flagSets) {
+function sanitizeFlagSets(log, flagSets, method) {
     var sanitizedSets = flagSets
         .map(function (flagSet) {
         if (CAPITAL_LETTERS_REGEX.test(flagSet)) {
-            log.warn(WARN_SPLITS_FILTER_LOWERCASE_SET, [flagSet]);
+            log.warn(WARN_LOWERCASE_FLAGSET, [method, flagSet]);
             flagSet = flagSet.toLowerCase();
         }
         return flagSet;
     })
         .filter(function (flagSet) {
         if (!VALID_FLAGSET_REGEX.test(flagSet)) {
-            log.warn(WARN_SPLITS_FILTER_INVALID_SET, [flagSet, VALID_FLAGSET_REGEX, flagSet]);
+            log.warn(WARN_INVALID_FLAGSET, [method, flagSet, VALID_FLAGSET_REGEX, flagSet]);
             return false;
         }
         if (typeof flagSet !== 'string')
@@ -137,7 +138,7 @@ export function validateSplitFilters(log, maybeSplitFilters, mode) {
     if (!maybeSplitFilters)
         return res;
     // Warn depending on the mode
-    if (mode === CONSUMER_MODE || mode === CONSUMER_PARTIAL_MODE) {
+    if (isConsumerMode(mode)) {
         log.warn(WARN_SPLITS_FILTER_IGNORED);
         return res;
     }
@@ -175,9 +176,9 @@ export function validateSplitFilters(log, maybeSplitFilters, mode) {
     log.debug(SETTINGS_SPLITS_FILTER, [res.queryString]);
     return res;
 }
-export function flagSetsAreValid(log, method, flagSets, flagSetsInConfig) {
+export function validateFlagSets(log, method, flagSets, flagSetsInConfig) {
     var sets = validateSplits(log, flagSets, method, 'flag sets', 'flag set');
-    var toReturn = sets ? sanitizeFlagSets(log, sets) : [];
+    var toReturn = sets ? sanitizeFlagSets(log, sets, method) : [];
     if (flagSetsInConfig.length > 0) {
         toReturn = toReturn.filter(function (flagSet) {
             if (flagSetsInConfig.indexOf(flagSet) > -1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.12.1-rc.3",
+  "version": "1.12.1-rc.5",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/logger/constants.ts

@@ -97,8 +97,8 @@ export const WARN_SPLITS_FILTER_EMPTY = 221;
 export const WARN_SDK_KEY = 222;
 export const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export const STREAMING_PARSING_SPLIT_UPDATE = 224;
-export const WARN_SPLITS_FILTER_INVALID_SET = 225;
-export const WARN_SPLITS_FILTER_LOWERCASE_SET = 226;
+export const WARN_INVALID_FLAGSET = 225;
+export const WARN_LOWERCASE_FLAGSET = 226;
 export const WARN_FLAGSET_NOT_CONFIGURED = 227;
 export const WARN_FLAGSET_WITHOUT_FLAGS = 228;
 

package/src/logger/messages/warn.ts

@@ -34,7 +34,7 @@ export const codesWarn: [number, string][] = codesError.concat([
 
   [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],
   [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing SPLIT_UPDATE notification: %s'],
-  [c.WARN_SPLITS_FILTER_INVALID_SET, c.LOG_PREFIX_SETTINGS + ': you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
-  [c.WARN_SPLITS_FILTER_LOWERCASE_SET, c.LOG_PREFIX_SETTINGS + ': flag set %s should be all lowercase - converting string to lowercase.'],
+  [c.WARN_INVALID_FLAGSET, '%s: you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
+  [c.WARN_LOWERCASE_FLAGSET, '%s: flag set %s should be all lowercase - converting string to lowercase.'],
   [c.WARN_FLAGSET_WITHOUT_FLAGS, '%s: you passed %s flag set that does not contain cached feature flag names. Please double check what flag sets are in use in the Split user interface.'],
 ]);

package/src/sdkClient/client.ts

@@ -4,12 +4,12 @@ import { getMatching, getBucketing } from '../utils/key';
 import { validateSplitExistence } from '../utils/inputValidation/splitExistence';
 import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
 import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET } from '../utils/constants';
+import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, TRACK_FN_LABEL } from '../utils/constants';
 import { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-import { isStorageSync } from '../trackers/impressionObserver/utils';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { Method } from '../sync/submitters/types';
 
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
@@ -28,13 +28,14 @@ function treatmentsNotReady(featureFlagNames: string[]) {
 export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient {
   const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker, telemetryTracker } = params;
   const { log, mode } = settings;
+  const isAsync = isConsumerMode(mode);
 
-  function getTreatment(key: SplitIO.SplitKey, featureFlagName: string, attributes: SplitIO.Attributes | undefined, withConfig = false) {
+  function getTreatment(key: SplitIO.SplitKey, featureFlagName: string, attributes: SplitIO.Attributes | undefined, withConfig = false, methodName = GET_TREATMENT) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
 
     const wrapUp = (evaluationResult: IEvaluationResult) => {
       const queue: ImpressionDTO[] = [];
-      const treatment = processEvaluation(evaluationResult, featureFlagName, key, attributes, withConfig, `getTreatment${withConfig ? 'withConfig' : ''}`, queue);
+      const treatment = processEvaluation(evaluationResult, featureFlagName, key, attributes, withConfig, methodName, queue);
       impressionsTracker.track(queue, attributes);
 
       stopTelemetryTracker(queue[0] && queue[0].label);
@@ -43,25 +44,25 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
 
     const evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
       evaluateFeature(log, key, featureFlagName, attributes, storage) :
-      isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-        treatmentNotReady :
-        Promise.resolve(treatmentNotReady); // Promisify if async
+      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) :
+        treatmentNotReady;
 
     return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
   }
 
   function getTreatmentWithConfig(key: SplitIO.SplitKey, featureFlagName: string, attributes: SplitIO.Attributes | undefined) {
-    return getTreatment(key, featureFlagName, attributes, true);
+    return getTreatment(key, featureFlagName, attributes, true, GET_TREATMENT_WITH_CONFIG);
   }
 
-  function getTreatments(key: SplitIO.SplitKey, featureFlagNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false) {
+  function getTreatments(key: SplitIO.SplitKey, featureFlagNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false, methodName = GET_TREATMENTS) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
 
     const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
       const queue: ImpressionDTO[] = [];
       const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
       Object.keys(evaluationResults).forEach(featureFlagName => {
-        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, attributes, withConfig, `getTreatments${withConfig ? 'withConfig' : ''}`, queue);
+        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, attributes, withConfig, methodName, queue);
       });
       impressionsTracker.track(queue, attributes);
 
@@ -71,26 +72,26 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
 
     const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
       evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
-      isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-        treatmentsNotReady(featureFlagNames) :
-        Promise.resolve(treatmentsNotReady(featureFlagNames)); // Promisify if async
+      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)) :
+        treatmentsNotReady(featureFlagNames);
 
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }
 
   function getTreatmentsWithConfig(key: SplitIO.SplitKey, featureFlagNames: string[], attributes: SplitIO.Attributes | undefined) {
-    return getTreatments(key, featureFlagNames, attributes, true);
+    return getTreatments(key, featureFlagNames, attributes, true, GET_TREATMENTS_WITH_CONFIG);
   }
 
-  function getTreatmentsByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false, method: Method = TREATMENTS_BY_FLAGSETS) {
+  function getTreatmentsByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false, method: Method = TREATMENTS_BY_FLAGSETS, methodName = GET_TREATMENTS_BY_FLAG_SETS) {
     const stopTelemetryTracker = telemetryTracker.trackEval(method);
 
-    const wrapUp = (evaluationResults: Record<string,IEvaluationResult>) => {
+    const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
       const queue: ImpressionDTO[] = [];
       const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
       const evaluations = evaluationResults;
       Object.keys(evaluations).forEach(featureFlagName => {
-        treatments[featureFlagName] = processEvaluation(evaluations[featureFlagName], featureFlagName, key, attributes, withConfig, `getTreatmentsByFlagSets${withConfig ? 'WithConfig' : ''}`, queue);
+        treatments[featureFlagName] = processEvaluation(evaluations[featureFlagName], featureFlagName, key, attributes, withConfig, methodName, queue);
       });
       impressionsTracker.track(queue, attributes);
 
@@ -99,22 +100,24 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, method) :
-      isStorageSync(settings) ? {} : Promise.resolve({}); // Promisify if async
+      evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
+      isAsync ?
+        Promise.resolve({}) :
+        {};
 
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }
 
   function getTreatmentsWithConfigByFlagSets(key: SplitIO.SplitKey, flagSetNames: string[], attributes: SplitIO.Attributes | undefined) {
-    return getTreatmentsByFlagSets(key, flagSetNames, attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS);
+    return getTreatmentsByFlagSets(key, flagSetNames, attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS);
   }
 
   function getTreatmentsByFlagSet(key: SplitIO.SplitKey, flagSetName: string, attributes: SplitIO.Attributes | undefined) {
-    return getTreatmentsByFlagSets(key, [flagSetName], attributes, false, TREATMENTS_BY_FLAGSET);
+    return getTreatmentsByFlagSets(key, [flagSetName], attributes, false, TREATMENTS_BY_FLAGSET, GET_TREATMENTS_BY_FLAG_SET);
   }
 
   function getTreatmentsWithConfigByFlagSet(key: SplitIO.SplitKey, flagSetName: string, attributes: SplitIO.Attributes | undefined) {
-    return getTreatmentsByFlagSets(key, [flagSetName], attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET);
+    return getTreatmentsByFlagSets(key, [flagSetName], attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
   }
 
   // Internal function
@@ -171,7 +174,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
-    validateTrafficTypeExistence(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
+    validateTrafficTypeExistence(log, readinessManager, storage.splits, mode, trafficTypeName, TRACK_FN_LABEL);
 
     const result = eventTracker.track(eventData, size);