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

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

package/esm/readiness/readinessManager.js

@@ -1,6 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
-import { STORAGE_LOCALSTORAGE } from '../utils/constants';
 function splitsEventEmitterFactory(EventEmitter) {
     var splitsEventEmitter = objectAssign(new EventEmitter(), {
         splitsArrived: false,
@@ -72,7 +71,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         if (!isReady && !isDestroyed) {
             try {
                 syncLastUpdate();
-                gate.emit(SDK_READY_FROM_CACHE);
+                gate.emit(SDK_READY_FROM_CACHE, isReady);
             }
             catch (e) {
                 // throws user callback exceptions in next tick
@@ -81,7 +80,6 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
         }
     }
     function checkIsReadyOrUpdate(diff) {
-        var _a;
         if (isDestroyed)
             return;
         if (isReady) {
@@ -100,9 +98,9 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
                 isReady = true;
                 try {
                     syncLastUpdate();
-                    if (!isReadyFromCache && ((_a = settings.storage) === null || _a === void 0 ? void 0 : _a.type) === STORAGE_LOCALSTORAGE) {
+                    if (!isReadyFromCache) {
                         isReadyFromCache = true;
-                        gate.emit(SDK_READY_FROM_CACHE);
+                        gate.emit(SDK_READY_FROM_CACHE, isReady);
                     }
                     gate.emit(SDK_READY);
                 }

package/esm/readiness/sdkReadinessManager.js

@@ -5,6 +5,7 @@ import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from
 import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
 var NEW_LISTENER_EVENT = 'newListener';
 var REMOVE_LISTENER_EVENT = 'removeListener';
+var TIMEOUT_ERROR = new Error(SDK_READY_TIMED_OUT);
 /**
  * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
  * It also updates logs related warnings and errors.
@@ -31,6 +32,9 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
                 readyCbCount++;
             }
         }
+        else if (event === SDK_READY_FROM_CACHE && readinessManager.isReadyFromCache()) {
+            log.error(ERROR_CLIENT_LISTENER, ['SDK_READY_FROM_CACHE']);
+        }
     });
     /** Ready promise */
     var readyPromise = generateReadyPromise();
@@ -55,6 +59,17 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
         }), defaultOnRejected);
         return promise;
     }
+    function getStatus() {
+        return {
+            isReady: readinessManager.isReady(),
+            isReadyFromCache: readinessManager.isReadyFromCache(),
+            isTimedout: readinessManager.isTimedout(),
+            hasTimedout: readinessManager.hasTimedout(),
+            isDestroyed: readinessManager.isDestroyed(),
+            isOperational: readinessManager.isOperational(),
+            lastUpdate: readinessManager.lastUpdate(),
+        };
+    }
     return {
         readinessManager: readinessManager,
         shared: function () {
@@ -73,6 +88,7 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
                 SDK_UPDATE: SDK_UPDATE,
                 SDK_READY_TIMED_OUT: SDK_READY_TIMED_OUT,
             },
+            // @TODO: remove in next major
             ready: function () {
                 if (readinessManager.hasTimedout()) {
                     if (!readinessManager.isReady()) {
@@ -84,17 +100,37 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
                 }
                 return readyPromise;
             },
-            __getStatus: function () {
-                return {
-                    isReady: readinessManager.isReady(),
-                    isReadyFromCache: readinessManager.isReadyFromCache(),
-                    isTimedout: readinessManager.isTimedout(),
-                    hasTimedout: readinessManager.hasTimedout(),
-                    isDestroyed: readinessManager.isDestroyed(),
-                    isOperational: readinessManager.isOperational(),
-                    lastUpdate: readinessManager.lastUpdate(),
-                };
+            whenReady: function () {
+                return new Promise(function (resolve, reject) {
+                    if (readinessManager.isReady()) {
+                        resolve();
+                    }
+                    else if (readinessManager.hasTimedout()) {
+                        reject(TIMEOUT_ERROR);
+                    }
+                    else {
+                        readinessManager.gate.once(SDK_READY, resolve);
+                        readinessManager.gate.once(SDK_READY_TIMED_OUT, function () { return reject(TIMEOUT_ERROR); });
+                    }
+                });
+            },
+            whenReadyFromCache: function () {
+                return new Promise(function (resolve, reject) {
+                    if (readinessManager.isReadyFromCache()) {
+                        resolve(readinessManager.isReady());
+                    }
+                    else if (readinessManager.hasTimedout()) {
+                        reject(TIMEOUT_ERROR);
+                    }
+                    else {
+                        readinessManager.gate.once(SDK_READY_FROM_CACHE, function () { return resolve(readinessManager.isReady()); });
+                        readinessManager.gate.once(SDK_READY_TIMED_OUT, function () { return reject(TIMEOUT_ERROR); });
+                    }
+                });
             },
+            getStatus: getStatus,
+            // @TODO: remove in next major
+            __getStatus: getStatus
         })
     };
 }

package/esm/sdkClient/client.js

@@ -41,7 +41,7 @@ export function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatment;
         };
-        var evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+        var evaluation = readinessManager.isReadyFromCache() ?
             evaluateFeature(log, key, featureFlagName, attributes, storage) :
             isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
                 Promise.resolve(treatmentNotReady) :
@@ -66,7 +66,7 @@ export function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatments;
         };
-        var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+        var evaluations = readinessManager.isReadyFromCache() ?
             evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
             isAsync ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
                 Promise.resolve(treatmentsNotReady(featureFlagNames)) :
@@ -92,7 +92,7 @@ export function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatments;
         };
-        var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+        var evaluations = readinessManager.isReadyFromCache() ?
             evaluateFeaturesByFlagSets(log, key, flagSetNames, attributes, storage, methodName) :
             isAsync ?
                 Promise.resolve({}) :
@@ -117,7 +117,7 @@ export function clientFactory(params) {
         if (treatment === CONTROL) {
             var fallbackTreatment = fallbackTreatmentsCalculator.resolve(featureFlagName, label);
             treatment = fallbackTreatment.treatment;
-            label = fallbackTreatment.label ? fallbackTreatment.label : label;
+            label = fallbackTreatment.label;
             config = fallbackTreatment.config;
         }
         log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);

package/esm/sdkClient/clientInputValidation.js

@@ -1,4 +1,4 @@
-import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational, validateEvaluationOptions } from '../utils/inputValidation';
+import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfReadyFromCache, validateEvaluationOptions } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
 import { 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';
@@ -23,7 +23,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         var attributes = validateAttributes(log, maybeAttributes, methodName);
         var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
         var options = validateEvaluationOptions(log, maybeOptions, methodName);
-        validateIfOperational(log, readinessManager, methodName, nameOrNames);
+        validateIfReadyFromCache(log, readinessManager, methodName, nameOrNames);
         var valid = isNotDestroyed && key && nameOrNames && attributes !== false;
         return {
             valid: valid,

package/esm/sdkManager/index.js

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

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -1,4 +1,5 @@
 import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
+import { checkIfServerSide } from '../../utils/key';
 import { findLatencyIndex } from '../findLatencyIndex';
 var MAX_STREAMING_EVENTS = 20;
 var MAX_TAGS = 10;
@@ -15,7 +16,7 @@ var ACCEPTANCE_RANGE = 0.001;
  */
 export function shouldRecordTelemetry(_a) {
     var settings = _a.settings;
-    return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
+    return settings.mode !== LOCALHOST_MODE && (checkIfServerSide(settings) || Math.random() <= ACCEPTANCE_RANGE);
 }
 var TelemetryCacheInMemory = /** @class */ (function () {
     function TelemetryCacheInMemory(splits, segments, largeSegments) {

package/esm/storages/pluggable/index.js

@@ -20,6 +20,7 @@ import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS
 import { metadataBuilder } from '../utils';
 import { LOG_PREFIX } from '../pluggable/constants';
 import { RBSegmentsCachePluggable } from './RBSegmentsCachePluggable';
+import { checkIfServerSide } from '../../utils/key';
 var NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 var NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
 /**
@@ -67,7 +68,7 @@ export function PluggableStorage(options) {
             new ImpressionCountsCacheInMemory() :
             new ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper);
         var uniqueKeysCache = isPartialConsumer ?
-            settings.core.key === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
+            checkIfServerSide(settings) ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
             new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper);
         // Connects to wrapper and emits SDK_READY event on main client
         var connectPromise = wrapper.connect().then(function () {

package/esm/sync/polling/fetchers/splitChangesFetcher.js

@@ -1,6 +1,7 @@
 import { FLAG_SPEC_VERSION } from '../../../utils/constants';
 import { base } from '../../../utils/settingsValidation';
 import { LOG_PREFIX_SYNC_SPLITS } from '../../../logger/constants';
+import { checkIfServerSide } from '../../../utils/key';
 var PROXY_CHECK_INTERVAL_MILLIS_CS = 60 * 60 * 1000; // 1 hour in Client Side
 var PROXY_CHECK_INTERVAL_MILLIS_SS = 24 * PROXY_CHECK_INTERVAL_MILLIS_CS; // 24 hours in Server Side
 function sdkEndpointOverridden(settings) {
@@ -13,7 +14,7 @@ function sdkEndpointOverridden(settings) {
 // @TODO breaking: drop support for Split Proxy below v5.10.0 and simplify the implementation
 export function splitChangesFetcherFactory(fetchSplitChanges, settings, storage) {
     var log = settings.log;
-    var PROXY_CHECK_INTERVAL_MILLIS = settings.core.key !== undefined ? PROXY_CHECK_INTERVAL_MILLIS_CS : PROXY_CHECK_INTERVAL_MILLIS_SS;
+    var PROXY_CHECK_INTERVAL_MILLIS = checkIfServerSide(settings) ? PROXY_CHECK_INTERVAL_MILLIS_SS : PROXY_CHECK_INTERVAL_MILLIS_CS;
     var lastProxyCheckTimestamp;
     return function splitChangesFetcher(since, noCache, till, rbSince, 
     // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker

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

@@ -1,4 +1,5 @@
 import { decorateHeaders } from '../../../services/decorateHeaders';
+import { checkIfServerSide } from '../../../utils/key';
 import { isString } from '../../../utils/lang';
 import { objectAssign } from '../../../utils/lang/objectAssign';
 var ABLY_API_VERSION = '1.1';
@@ -57,7 +58,7 @@ var SSEClient = /** @class */ (function () {
             return encodeURIComponent(params + channel);
         }).join(',');
         var url = this.settings.urls.streaming + "/sse?channels=" + channelsQueryParam + "&accessToken=" + authToken.token + "&v=" + ABLY_API_VERSION + "&heartbeats=true"; // same results using `&heartbeats=false`
-        var isServerSide = !this.settings.core.key;
+        var isServerSide = checkIfServerSide(this.settings);
         this.connection = new this.eventSource(
         // For client-side SDKs, metadata is passed as query param to avoid CORS issues and because native EventSource implementations in browsers do not support headers
         isServerSide ? url : url + ("&SplitSDKVersion=" + this.headers.SplitSDKVersion + "&SplitSDKClientKey=" + this.headers.SplitSDKClientKey), 

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

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

package/esm/sync/streaming/pushManager.js

@@ -7,7 +7,7 @@ import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
 import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
-import { getMatching } from '../../utils/key';
+import { checkIfServerSide, getMatching } from '../../utils/key';
 import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, RB_SEGMENT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
@@ -23,7 +23,7 @@ export function pushManagerFactory(params, pollingManager) {
     var settings = params.settings, storage = params.storage, splitApi = params.splitApi, readiness = params.readiness, platform = params.platform, telemetryTracker = params.telemetryTracker;
     // `userKey` is the matching key of main client in client-side SDK.
     // It can be used to check if running on client-side or server-side SDK.
-    var userKey = settings.core.key ? getMatching(settings.core.key) : undefined;
+    var userKey = checkIfServerSide(settings) ? undefined : getMatching(settings.core.key);
     var log = settings.log;
     var sseClient;
     try {

package/esm/sync/submitters/telemetrySubmitter.js

@@ -6,6 +6,7 @@ import { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
 import { objectAssign } from '../../utils/lang/objectAssign';
+import { checkIfServerSide } from '../../utils/key';
 var OPERATION_MODE_MAP = (_a = {},
     _a[STANDALONE_MODE] = STANDALONE_ENUM,
     _a[CONSUMER_MODE] = CONSUMER_ENUM,
@@ -58,14 +59,14 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
         clear: function () { },
         pop: function () {
             var urls = settings.urls, scheduler = settings.scheduler;
-            var isClientSide = settings.core.key !== undefined;
+            var isServerSide = checkIfServerSide(settings);
             var _a = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation), flagSetsTotal = _a.flagSetsTotal, flagSetsIgnored = _a.flagSetsIgnored;
             return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
                 rR: {
                     sp: scheduler.featuresRefreshRate / 1000,
-                    se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
-                    ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+                    se: isServerSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+                    ms: isServerSide ? undefined : scheduler.segmentsRefreshRate / 1000,
                     im: scheduler.impressionsRefreshRate / 1000,
                     ev: scheduler.eventsPushRate / 1000,
                     te: scheduler.telemetryRefreshRate / 1000,
@@ -102,14 +103,14 @@ export function telemetrySubmitterFactory(params) {
     if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
     var settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
-    var startTime = timer(now);
+    var stopTimer = timer(now);
     var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
-        telemetry.recordTimeUntilReadyFromCache(startTime());
+        telemetry.recordTimeUntilReadyFromCache(stopTimer());
     });
     sdkReadinessManager.incInternalReadyCbCount();
     readiness.gate.once(SDK_READY, function () {
-        telemetry.recordTimeUntilReady(startTime());
+        telemetry.recordTimeUntilReady(stopTimer());
         // Post config data when the SDK is ready and if the telemetry submitter was started
         if (submitter.isRunning()) {
             var postMetricsConfigTask = submitterFactory(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, undefined, 0, true);

package/esm/trackers/telemetryTracker.js

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

package/esm/utils/inputValidation/index.js

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

package/esm/utils/inputValidation/isOperational.js

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

package/esm/utils/inputValidation/splitExistence.js

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

package/esm/utils/key/index.js

@@ -28,3 +28,6 @@ export function keyParser(key) {
         };
     }
 }
+export function checkIfServerSide(settings) {
+    return !settings.core.key;
+}

package/package.json

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

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

@@ -1,8 +1,11 @@
 import { Treatment, TreatmentWithConfig } from '../../../../types/splitio';
 import { ILogger } from '../../../logger/types';
 import { isObject, isString } from '../../../utils/lang';
-import { FallbackDiscardReason } from '../constants';
 
+enum FallbackDiscardReason {
+  FlagName = 'Invalid flag name (max 100 chars, no spaces)',
+  Treatment = 'Invalid treatment (max 100 chars and must match pattern)',
+}
 
 export class FallbacksSanitizer {
 

package/src/logger/constants.ts

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

package/src/logger/index.ts

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

package/src/readiness/readinessManager.ts

@@ -3,7 +3,6 @@ import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
 import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, ISplitsEventEmitter } from './types';
-import { STORAGE_LOCALSTORAGE } from '../utils/constants';
 
 function splitsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter): ISplitsEventEmitter {
   const splitsEventEmitter = objectAssign(new EventEmitter(), {
@@ -91,7 +90,7 @@ export function readinessManagerFactory(
     if (!isReady && !isDestroyed) {
       try {
         syncLastUpdate();
-        gate.emit(SDK_READY_FROM_CACHE);
+        gate.emit(SDK_READY_FROM_CACHE, isReady);
       } catch (e) {
         // throws user callback exceptions in next tick
         setTimeout(() => { throw e; }, 0);
@@ -115,9 +114,9 @@ export function readinessManagerFactory(
         isReady = true;
         try {
           syncLastUpdate();
-          if (!isReadyFromCache && settings.storage?.type === STORAGE_LOCALSTORAGE) {
+          if (!isReadyFromCache) {
             isReadyFromCache = true;
-            gate.emit(SDK_READY_FROM_CACHE);
+            gate.emit(SDK_READY_FROM_CACHE, isReady);
           }
           gate.emit(SDK_READY);
         } catch (e) {