@splitsoftware/splitio-commons 1.6.2-rc.7 → 1.6.2-rc.9

package/esm/storages/pluggable/TelemetryCachePluggable.js

@@ -1,4 +1,10 @@
+import { parseExceptionField, parseLatencyField, parseMetadata } from '../KeyBuilderSS';
 import { findLatencyIndex } from '../findLatencyIndex';
+import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
+import { CONSUMER_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
+import { isString, isNaNNumber } from '../../utils/lang';
+import { _Map } from '../../utils/lang/maps';
+import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 var TelemetryCachePluggable = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses a storage wrapper.
@@ -19,6 +25,126 @@ var TelemetryCachePluggable = /** @class */ (function () {
         return this.wrapper.incr(this.keys.buildExceptionKey(method))
             .catch(function () { });
     };
+    TelemetryCachePluggable.prototype.recordConfig = function () {
+        var value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, STORAGE_PLUGGABLE));
+        return this.wrapper.set(this.keys.buildInitKey(), value).catch(function () { });
+    };
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popLatencies = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.latencyPrefix).then(function (latencyKeys) {
+            return latencyKeys.length ?
+                _this.wrapper.getMany(latencyKeys).then(function (latencies) {
+                    var result = new _Map();
+                    for (var i = 0; i < latencyKeys.length; i++) {
+                        var field = latencyKeys[i].split('::')[1];
+                        var parsedField = parseLatencyField(field);
+                        if (isString(parsedField)) {
+                            _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        // @ts-ignore
+                        var count = parseInt(latencies[i]);
+                        if (isNaNNumber(count)) {
+                            _this.log.error("Ignoring latency with invalid count: " + latencies[i]);
+                            continue;
+                        }
+                        var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
+                        if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
+                            _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                            continue;
+                        }
+                        if (!result.has(metadata))
+                            result.set(metadata, {
+                                t: newBuckets(),
+                                ts: newBuckets(),
+                                tc: newBuckets(),
+                                tcs: newBuckets(),
+                                tr: newBuckets(),
+                            });
+                        result.get(metadata)[method][bucket] = count;
+                    }
+                    return Promise.all(latencyKeys.map(function (latencyKey) { return _this.wrapper.del(latencyKey); })).then(function () { return result; });
+                }) :
+                // If latencyKeys is empty, return an empty map.
+                new _Map();
+        });
+    };
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popExceptions = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.exceptionPrefix).then(function (exceptionKeys) {
+            return exceptionKeys.length ?
+                _this.wrapper.getMany(exceptionKeys).then(function (exceptions) {
+                    var result = new _Map();
+                    for (var i = 0; i < exceptionKeys.length; i++) {
+                        var field = exceptionKeys[i].split('::')[1];
+                        var parsedField = parseExceptionField(field);
+                        if (isString(parsedField)) {
+                            _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        // @ts-ignore
+                        var count = parseInt(exceptions[i]);
+                        if (isNaNNumber(count)) {
+                            _this.log.error("Ignoring exception with invalid count: " + exceptions[i]);
+                            continue;
+                        }
+                        var metadata = parsedField[0], method = parsedField[1];
+                        if (!result.has(metadata))
+                            result.set(metadata, {
+                                t: 0,
+                                ts: 0,
+                                tc: 0,
+                                tcs: 0,
+                                tr: 0,
+                            });
+                        result.get(metadata)[method] = count;
+                    }
+                    return Promise.all(exceptionKeys.map(function (exceptionKey) { return _this.wrapper.del(exceptionKey); })).then(function () { return result; });
+                }) :
+                // If exceptionKeys is empty, return an empty map.
+                new _Map();
+        });
+    };
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popConfigs = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.initPrefix).then(function (configKeys) {
+            return configKeys.length ?
+                _this.wrapper.getMany(configKeys).then(function (configs) {
+                    var result = new _Map();
+                    for (var i = 0; i < configKeys.length; i++) {
+                        var field = configKeys[i].split('::')[1];
+                        var parsedField = parseMetadata(field);
+                        if (isString(parsedField)) {
+                            _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        var metadata = parsedField[0];
+                        try { // @ts-ignore
+                            var config = JSON.parse(configs[i]);
+                            result.set(metadata, config);
+                        }
+                        catch (e) {
+                            _this.log.error("Ignoring invalid config: " + configs[i]);
+                        }
+                    }
+                    return Promise.all(configKeys.map(function (configKey) { return _this.wrapper.del(configKey); })).then(function () { return result; });
+                }) :
+                // If configKeys is empty, return an empty map.
+                new _Map();
+        });
+    };
     return TelemetryCachePluggable;
 }());
 export { TelemetryCachePluggable };

package/esm/storages/pluggable/index.js

@@ -11,6 +11,8 @@ import { CONSUMER_PARTIAL_MODE, STORAGE_PLUGGABLE } from '../../utils/constants'
 import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
+import { TelemetryCachePluggable } from './TelemetryCachePluggable';
 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.';
 /**
@@ -27,15 +29,6 @@ function validatePluggableStorageOptions(options) {
     if (missingMethods.length)
         throw new Error(NO_VALID_WRAPPER_INTERFACE + " The following methods are missing or invalid: " + missingMethods);
 }
-// subscription to wrapper connect event in order to emit SDK_READY event
-function wrapperConnect(wrapper, onReadyCb) {
-    wrapper.connect().then(function () {
-        onReadyCb();
-        // At the moment, we don't synchronize config with pluggable storage
-    }).catch(function (e) {
-        onReadyCb(e || new Error('Error connecting wrapper'));
-    });
-}
 // Async return type in `client.track` method on consumer partial mode
 // No need to promisify impressions cache
 function promisifyEventsTrack(events) {
@@ -51,28 +44,39 @@ function promisifyEventsTrack(events) {
 export function PluggableStorage(options) {
     validatePluggableStorageOptions(options);
     var prefix = validatePrefix(options.prefix);
-    function PluggableStorageFactory(_a) {
-        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, mode = _a.mode, eventsQueueSize = _a.eventsQueueSize, impressionsQueueSize = _a.impressionsQueueSize, optimize = _a.optimize;
+    function PluggableStorageFactory(params) {
+        var log = params.log, metadata = params.metadata, onReadyCb = params.onReadyCb, mode = params.mode, eventsQueueSize = params.eventsQueueSize, impressionsQueueSize = params.impressionsQueueSize, optimize = params.optimize;
         var keys = new KeyBuilderSS(prefix, metadata);
         var wrapper = wrapperAdapter(log, options.wrapper);
         var isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
+        var telemetry = shouldRecordTelemetry(params) ?
+            isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper) :
+            undefined;
         // Connects to wrapper and emits SDK_READY event on main client
-        wrapperConnect(wrapper, onReadyCb);
+        var connectPromise = wrapper.connect().then(function () {
+            onReadyCb();
+            // If mode is not defined, it means that the synchronizer is running and so we don't have to record telemetry
+            if (telemetry && telemetry.recordConfig && mode)
+                telemetry.recordConfig();
+        }).catch(function (e) {
+            e = e || new Error('Error connecting wrapper');
+            onReadyCb(e);
+            return e;
+        });
         return {
             splits: new SplitsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable(log, keys, wrapper),
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
             impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-            // @TODO Not using TelemetryCachePluggable yet because it's not supported by the Split Synchronizer, and needs to drop or queue operations while the wrapper is not ready
-            // telemetry: isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper),
+            telemetry: telemetry,
             // Disconnect the underlying storage
             destroy: function () {
                 return wrapper.disconnect();
             },
             // emits SDK_READY event on shared clients and returns a reference to the storage
             shared: function (_, onReadyCb) {
-                wrapperConnect(wrapper, onReadyCb);
+                connectPromise.then(onReadyCb);
                 return __assign(__assign({}, this), { 
                     // no-op destroy, to disconnect the wrapper only when the main client is destroyed
                     destroy: function () { } });

package/esm/sync/submitters/submitterManager.js

@@ -2,7 +2,6 @@ import { eventsSubmitterFactory } from './eventsSubmitter';
 import { impressionsSubmitterFactory } from './impressionsSubmitter';
 import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
 import { telemetrySubmitterFactory } from './telemetrySubmitter';
-import { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';
 export function submitterManagerFactory(params) {
     var submitters = [
         impressionsSubmitterFactory(params),
@@ -12,8 +11,6 @@ export function submitterManagerFactory(params) {
     if (impressionCountsSubmitter)
         submitters.push(impressionCountsSubmitter);
     var telemetrySubmitter = telemetrySubmitterFactory(params);
-    if (params.uniqueKeysTracker)
-        submitters.push(uniqueKeysSubmitterFactory(params));
     return {
         // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
         start: function (onlyTelemetry) {

package/esm/sync/submitters/telemetrySubmitter.js

@@ -1,11 +1,12 @@
 var _a, _b, _c;
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
+import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
 import { objectAssign } from '../../utils/lang/objectAssign';
+import { isStorageSync } from '../../trackers/impressionObserver/utils';
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
  */
@@ -26,9 +27,9 @@ export function telemetryCacheStatsAdapter(telemetry, splits, segments) {
                 iQ: telemetry.getImpressionStats(QUEUED),
                 iDe: telemetry.getImpressionStats(DEDUPED),
                 iDr: telemetry.getImpressionStats(DROPPED),
-                spC: splits.getSplitNames().length,
-                seC: segments.getRegisteredSegments().length,
-                skC: segments.getKeysCount(),
+                spC: splits && splits.getSplitNames().length,
+                seC: segments && segments.getRegisteredSegments().length,
+                skC: segments && segments.getKeysCount(),
                 sL: telemetry.getSessionLength(),
                 eQ: telemetry.getEventStats(QUEUED),
                 eD: telemetry.getEventStats(DROPPED),
@@ -46,7 +47,6 @@ var OPERATION_MODE_MAP = (_a = {},
 var IMPRESSIONS_MODE_MAP = (_b = {},
     _b[OPTIMIZED] = OPTIMIZED_ENUM,
     _b[DEBUG] = DEBUG_ENUM,
-    _b[NONE] = NONE_ENUM,
     _b);
 var USER_CONSENT_MAP = (_c = {},
     _c[CONSENT_UNKNOWN] = 1,
@@ -120,7 +120,9 @@ export function telemetrySubmitterFactory(params) {
         return; // No submitter created if telemetry cache is not defined
     var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
     var startTime = timer(now);
-    var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
+    var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, 
+    // @TODO cannot provide splits and segments cache if they are async, because `submitterFactory` expects a sync storage source
+    isStorageSync(params.settings) ? telemetryCacheStatsAdapter(telemetry, splits, segments) : telemetryCacheStatsAdapter(telemetry), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());
     });

package/esm/trackers/impressionsTracker.js

@@ -1,5 +1,6 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
+import { truncateTimeFrame } from '../utils/time';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
 import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
 /**
@@ -9,34 +10,52 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * @param metadata runtime metadata (ip, hostname and version)
  * @param impressionListener optional impression listener
  * @param integrationsManager optional integrations manager
- * @param strategy strategy for impressions tracking.
+ * @param observer optional impression observer. If provided, previous time (pt property) is included in impression instances
+ * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
  */
-export function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {
+export function impressionsTrackerFactory(settings, impressionsCache, integrationsManager, 
+// if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
+observer, 
+// if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
+countsCache, telemetryCache) {
     var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
             if (settings.userConsent === CONSENT_DECLINED)
                 return;
             var impressionsCount = impressions.length;
-            var _a = strategy.process(impressions), impressionsToStore = _a.impressionsToStore, impressionsToListener = _a.impressionsToListener, deduped = _a.deduped;
-            var impressionsToListenerCount = impressionsToListener.length;
-            if (impressionsToStore.length > 0) {
-                var res = impressionsCache.track(impressionsToStore);
-                // If we're on an async storage, handle error and log it.
-                if (thenable(res)) {
-                    res.then(function () {
-                        log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-                    }).catch(function (err) {
-                        log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
-                    });
+            var impressionsToStore = []; // Track only the impressions that are going to be stored
+            // Wraps impressions to store and adds previousTime if it corresponds
+            impressions.forEach(function (impression) {
+                if (observer) {
+                    // Adds previous time if it is enabled
+                    impression.pt = observer.testAndSet(impression);
                 }
-                else {
-                    // Record when impressionsCache is sync only (standalone mode)
-                    // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-                    if (telemetryCache) {
-                        telemetryCache.recordImpressionStats(QUEUED, impressionsToStore.length);
-                        telemetryCache.recordImpressionStats(DEDUPED, deduped);
-                    }
+                var now = Date.now();
+                if (countsCache) {
+                    // Increments impression counter per featureName
+                    countsCache.track(impression.feature, now, 1);
+                }
+                // Checks if the impression should be added in queue to be sent
+                if (!countsCache || !impression.pt || impression.pt < truncateTimeFrame(now)) {
+                    impressionsToStore.push(impression);
+                }
+            });
+            var res = impressionsCache.track(impressionsToStore);
+            // If we're on an async storage, handle error and log it.
+            if (thenable(res)) {
+                res.then(function () {
+                    log.info(IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
+                }).catch(function (err) {
+                    log.error(ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
+                });
+            }
+            else {
+                // Record when impressionsCache is sync only (standalone mode)
+                // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
+                if (telemetryCache) {
+                    telemetryCache.recordImpressionStats(QUEUED, impressionsToStore.length);
+                    telemetryCache.recordImpressionStats(DEDUPED, impressions.length - impressionsToStore.length);
                 }
             }
             // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor
@@ -44,7 +63,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                 var _loop_1 = function (i) {
                     var impressionData = {
                         // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
-                        impression: objectAssign({}, impressionsToListener[i]),
+                        impression: objectAssign({}, impressions[i]),
                         attributes: attributes,
                         ip: ip,
                         hostname: hostname,
@@ -64,7 +83,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                         }
                     }, 0);
                 };
-                for (var i = 0; i < impressionsToListenerCount; i++) {
+                for (var i = 0; i < impressionsCount; i++) {
                     _loop_1(i);
                 }
             }

package/esm/utils/constants/index.js

@@ -13,7 +13,6 @@ export var SPLIT_EVENT = 'EVENT';
 // Impression collection modes
 export var DEBUG = 'DEBUG';
 export var OPTIMIZED = 'OPTIMIZED';
-export var NONE = 'NONE';
 // SDK Modes
 export var LOCALHOST_MODE = 'localhost';
 export var STANDALONE_MODE = 'standalone';
@@ -38,7 +37,6 @@ export var CONSUMER_ENUM = 1;
 export var CONSUMER_PARTIAL_ENUM = 2;
 export var OPTIMIZED_ENUM = 0;
 export var DEBUG_ENUM = 1;
-export var NONE_ENUM = 2;
 export var SPLITS = 'sp';
 export var IMPRESSIONS = 'im';
 export var IMPRESSIONS_COUNT = 'ic';

package/esm/utils/lang/maps.js

@@ -37,13 +37,6 @@ var MapPoly = /** @class */ (function () {
         this.__mapKeysData__.length = 0;
         this.__mapValuesData__.length = 0;
     };
-    MapPoly.prototype.set = function (key, value) {
-        var index = this.__mapKeysData__.indexOf(key);
-        if (index === -1)
-            index = this.__mapKeysData__.push(key) - 1;
-        this.__mapValuesData__[index] = value;
-        return this;
-    };
     MapPoly.prototype.delete = function (key) {
         var index = this.__mapKeysData__.indexOf(key);
         if (index === -1)
@@ -52,12 +45,27 @@ var MapPoly = /** @class */ (function () {
         this.__mapValuesData__.splice(index, 1);
         return true;
     };
+    MapPoly.prototype.forEach = function (callbackfn, thisArg) {
+        for (var i = 0; i < this.__mapKeysData__.length; i++) {
+            callbackfn.call(thisArg, this.__mapValuesData__[i], this.__mapKeysData__[i], this);
+        }
+    };
     MapPoly.prototype.get = function (key) {
         var index = this.__mapKeysData__.indexOf(key);
         if (index === -1)
             return;
         return this.__mapValuesData__[index];
     };
+    MapPoly.prototype.has = function (key) {
+        return this.__mapKeysData__.indexOf(key) !== -1;
+    };
+    MapPoly.prototype.set = function (key, value) {
+        var index = this.__mapKeysData__.indexOf(key);
+        if (index === -1)
+            index = this.__mapKeysData__.push(key) - 1;
+        this.__mapValuesData__[index] = value;
+        return this;
+    };
     Object.defineProperty(MapPoly.prototype, "size", {
         get: function () {
             return this.__mapKeysData__.length;

package/esm/utils/settingsValidation/impressionsMode.js

@@ -1,10 +1,10 @@
 import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
-import { DEBUG, OPTIMIZED, NONE } from '../constants';
+import { DEBUG, OPTIMIZED } from '../constants';
 import { stringToUpperCase } from '../lang';
 export function validImpressionsMode(log, impressionsMode) {
     impressionsMode = stringToUpperCase(impressionsMode);
-    if ([DEBUG, OPTIMIZED, NONE].indexOf(impressionsMode) > -1)
+    if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1)
         return impressionsMode;
-    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED, NONE], OPTIMIZED]);
+    log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
     return OPTIMIZED;
 }

package/esm/utils/settingsValidation/index.js

@@ -31,8 +31,6 @@ export var base = {
         telemetryRefreshRate: 3600,
         // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
         impressionsRefreshRate: 300,
-        // publish unique Keys each 900 sec (15 min) 
-        uniqueKeysRefreshRate: 900,
         // fetch offline changes each 15 sec
         offlineRefreshRate: 15,
         // publish events every 60 seconds after the first flush
@@ -111,8 +109,6 @@ export function settingsValidation(config, validationParams) {
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-    scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
-    scheduler.impressionCountsRefreshRate = fromSecondsToMillis(scheduler.impressionCountsRefreshRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
     // Default impressionsRefreshRate for DEBUG mode is 60 secs
     if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.7",
+  "version": "1.6.2-rc.9",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -24,6 +24,7 @@
     "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
     "test": "jest",
     "test:coverage": "jest --coverage",
+    "all": "npm run check && npm run build && npm run test",
     "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",
     "publish:stable": "npm run check && npm run test && npm run build && npm publish"
   },

package/src/consent/sdkUserConsent.ts

@@ -40,8 +40,8 @@ export function createUserConsentAPI(params: ISdkFactoryContext) {
 
           // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
           if (events.clear) events.clear(); // @ts-ignore
-          if (impressions.clear) impressions.clear();// @ts-ignore
-          if (impressionCounts && impressionCounts.clear) impressionCounts.clear();
+          if (impressions.clear) impressions.clear();
+          if (impressionCounts) impressionCounts.clear();
         }
       } else {
         log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);

package/src/evaluator/index.ts

@@ -29,19 +29,19 @@ export function evaluateFeature(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<IEvaluationResult> {
-  let stringifiedSplit;
+  let parsedSplit;
 
   try {
-    stringifiedSplit = storage.splits.getSplit(splitName);
+    parsedSplit = storage.splits.getSplit(splitName);
   } catch (e) {
     // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
     return treatmentException;
   }
 
-  if (thenable(stringifiedSplit)) {
-    return stringifiedSplit.then((result) => getEvaluation(
+  if (thenable(parsedSplit)) {
+    return parsedSplit.then((split) => getEvaluation(
       log,
-      result,
+      split,
       key,
       attributes,
       storage,
@@ -54,7 +54,7 @@ export function evaluateFeature(
 
   return getEvaluation(
     log,
-    stringifiedSplit,
+    parsedSplit,
     key,
     attributes,
     storage,

package/src/listeners/browser.ts

@@ -7,7 +7,7 @@ import { fromImpressionCountsCollector } from '../sync/submitters/impressionCoun
 import { IResponse, ISplitApi } from '../services/types';
 import { ImpressionDTO, ISettings } from '../types';
 import { ImpressionsPayload } from '../sync/submitters/types';
-import { OPTIMIZED, DEBUG, NONE } from '../utils/constants';
+import { OPTIMIZED, DEBUG } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
@@ -88,10 +88,9 @@ export class BrowserSignalListener implements ISignalListener {
     // Flush impressions & events data if there is user consent
     if (isConsentGranted(this.settings)) {
       const eventsUrl = this.settings.urls.events;
-      const sim = this.settings.sync.impressionsMode;
       const extraMetadata = {
         // sim stands for Sync/Split Impressions Mode
-        sim: sim === OPTIMIZED ? OPTIMIZED : sim === DEBUG ? DEBUG : NONE
+        sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
       };
 
       this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);

package/src/logger/constants.ts

@@ -143,5 +143,4 @@ export const LOG_PREFIX_SYNC_POLLING = LOG_PREFIX_SYNC + ':polling-manager: ';
 export const LOG_PREFIX_SYNC_SUBMITTERS = LOG_PREFIX_SYNC + ':submitter: ';
 export const LOG_PREFIX_IMPRESSIONS_TRACKER = 'impressions-tracker: ';
 export const LOG_PREFIX_EVENTS_TRACKER = 'events-tracker: ';
-export const LOG_PREFIX_UNIQUE_KEYS_TRACKER = 'unique-keys-tracker: ';
 export const LOG_PREFIX_CLEANUP = 'cleanup: ';

package/src/sdkClient/client.ts

@@ -9,6 +9,17 @@ 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';
+
+const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
+
+function treatmentsNotReady(splitNames: string[]) {
+  const evaluations: Record<string, IEvaluationResult> = {};
+  splitNames.forEach(splitName => {
+    evaluations[splitName] = treatmentNotReady;
+  });
+  return evaluations;
+}
 
 /**
  * Creator of base client with getTreatments and track methods.
@@ -29,7 +40,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatment;
     };
 
-    const evaluation = evaluateFeature(log, key, splitName, attributes, storage);
+    const evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+      evaluateFeature(log, key, splitName, 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
 
     return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
   }
@@ -53,7 +68,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatments;
     };
 
-    const evaluations = evaluateFeatures(log, key, splitNames, attributes, storage);
+    const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+      evaluateFeatures(log, key, splitNames, 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(splitNames) :
+        Promise.resolve(treatmentsNotReady(splitNames)); // Promisify if async
 
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }
@@ -72,15 +91,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     invokingMethodName: string,
     queue: ImpressionDTO[]
   ): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
-    const isSdkReady = readinessManager.isReady() || readinessManager.isReadyFromCache();
     const matchingKey = getMatching(key);
     const bucketingKey = getBucketing(key);
 
-    // If the SDK was not ready, treatment may be incorrect due to having Splits but not segments data.
-    if (!isSdkReady) {
-      evaluation = { treatment: CONTROL, label: SDK_NOT_READY };
-    }
-
     const { treatment, label, changeNumber, config = null } = evaluation;
     log.info(IMPRESSION, [splitName, matchingKey, treatment, label]);
 

package/src/sdkClient/sdkClient.ts

@@ -9,7 +9,7 @@ import { ISdkFactoryContext } from '../sdkFactory/types';
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
 export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker, uniqueKeysTracker } = params;
+  const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker } = params;
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
@@ -39,8 +39,6 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
 
           // Release the API Key if it is the main client
           if (!isSharedClient) releaseApiKey(settings.core.authorizationKey);
-          
-          if (uniqueKeysTracker) uniqueKeysTracker.stop();
 
           // Cleanup storage
           return storage.destroy();