@splitsoftware/splitio-commons 1.6.2-rc.1 → 1.6.2-rc.10

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, DEBUG_ENUM, OPTIMIZED_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, NONE, DEBUG_ENUM, OPTIMIZED_ENUM, NONE_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,6 +47,7 @@ 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,
@@ -119,7 +121,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/sync/submitters/uniqueKeysSubmitter.js

@@ -1,64 +1,23 @@
-import { setToArray } from '../../utils/lang/sets';
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
 import { submitterFactory } from './submitter';
-/**
- * Invert keys for feature to features for key
- */
-function invertUniqueKeys(uniqueKeys) {
-    var featureNames = Object.keys(uniqueKeys);
-    var inverted = {};
-    for (var i = 0; i < featureNames.length; i++) {
-        var featureName = featureNames[i];
-        var featureKeys = setToArray(uniqueKeys[featureName]);
-        for (var j = 0; j < featureKeys.length; j++) {
-            var featureKey = featureKeys[j];
-            if (!inverted[featureKey])
-                inverted[featureKey] = [];
-            inverted[featureKey].push(featureName);
-        }
-    }
-    return inverted;
-}
-/**
- * Converts `uniqueKeys` data from cache into request payload for CS.
- */
-export function fromUniqueKeysCollectorCs(uniqueKeys) {
-    var payload = [];
-    var featuresPerKey = invertUniqueKeys(uniqueKeys);
-    var keys = Object.keys(featuresPerKey);
-    for (var k = 0; k < keys.length; k++) {
-        var key = keys[k];
-        var uniqueKeysPayload = {
-            k: key,
-            fs: featuresPerKey[key]
-        };
-        payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-}
-/**
- * Converts `uniqueKeys` data from cache into request payload for SS.
- */
-export function fromUniqueKeysCollectorSs(uniqueKeys) {
-    var payload = [];
-    var featureNames = Object.keys(uniqueKeys);
-    for (var i = 0; i < featureNames.length; i++) {
-        var featureName = featureNames[i];
-        var featureKeys = setToArray(uniqueKeys[featureName]);
-        var uniqueKeysPayload = {
-            f: featureName,
-            ks: featureKeys
-        };
-        payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-}
+var DATA_NAME = 'unique keys';
+var UNIQUE_KEYS_RATE = 900000; // 15 minutes
 /**
  * Submitter that periodically posts impression counts
  */
 export function uniqueKeysSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, uniqueKeysRefreshRate = _a.scheduler.uniqueKeysRefreshRate, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
+    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
     var isClientSide = key !== undefined;
     var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
-    var fromUniqueKeysCollector = isClientSide ? fromUniqueKeysCollectorCs : fromUniqueKeysCollectorSs;
-    return submitterFactory(log, postUniqueKeysBulk, uniqueKeys, uniqueKeysRefreshRate, 'unique keys', fromUniqueKeysCollector);
+    var syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE, DATA_NAME);
+    // register unique keys submitter to be executed when uniqueKeys cache is full
+    uniqueKeys.setOnFullQueueCb(function () {
+        if (syncTask.isRunning()) {
+            log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+            syncTask.execute();
+        }
+        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
+        // Data will be sent when submitter is resumed.
+    });
+    return syncTask;
 }

package/esm/trackers/impressionsTracker.js

@@ -20,21 +20,23 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
             var impressionsCount = impressions.length;
             var _a = strategy.process(impressions), impressionsToStore = _a.impressionsToStore, impressionsToListener = _a.impressionsToListener, deduped = _a.deduped;
             var impressionsToListenerCount = impressionsToListener.length;
-            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, deduped);
+            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]);
+                    });
+                }
+                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);
+                    }
                 }
             }
             // @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

package/esm/trackers/strategy/strategyNone.js

@@ -13,7 +13,7 @@ export function strategyNoneFactory(impressionsCounter, uniqueKeysTracker) {
                 // Increments impression counter per featureName
                 impressionsCounter.track(impression.feature, now, 1);
                 // Keep track by unique key
-                uniqueKeysTracker.track(impression.feature, impression.keyName);
+                uniqueKeysTracker.track(impression.keyName, impression.feature);
             });
             return {
                 impressionsToStore: [],

package/esm/trackers/strategy/strategyOptimized.js

@@ -14,7 +14,8 @@ export function strategyOptimizedFactory(impressionsObserver, impressionsCounter
                 impression.pt = impressionsObserver.testAndSet(impression);
                 var now = Date.now();
                 // Increments impression counter per featureName
-                impressionsCounter.track(impression.feature, now, 1);
+                if (impression.pt)
+                    impressionsCounter.track(impression.feature, now, 1);
                 // Checks if the impression should be added in queue to be sent
                 if (!impression.pt || impression.pt < truncateTimeFrame(now)) {
                     impressionsToStore.push(impression);

package/esm/trackers/telemetryTracker.js

@@ -46,6 +46,11 @@ export function telemetryTrackerFactory(telemetryCache, now) {
                     if (e === TOKEN_REFRESH)
                         telemetryCache.recordTokenRefreshes();
                 }
+            },
+            addTag: function (tag) {
+                // @ts-ignore
+                if (telemetryCache.addTag)
+                    telemetryCache.addTag(tag);
             }
         };
     }
@@ -56,6 +61,7 @@ export function telemetryTrackerFactory(telemetryCache, now) {
             trackHttp: noopTrack,
             sessionLength: function () { },
             streamingEvent: function () { },
+            addTag: function () { }
         };
     }
 }

package/esm/trackers/uniqueKeysTracker.js

@@ -1,65 +1,34 @@
 import { LOG_PREFIX_UNIQUE_KEYS_TRACKER } from '../logger/constants';
-import { _Set } from '../utils/lang/sets';
 var noopFilterAdapter = {
     add: function () { return true; },
     contains: function () { return true; },
     clear: function () { }
 };
-var DEFAULT_CACHE_SIZE = 30000;
 /**
  * Trackes uniques keys
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
  *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
  *
  * @param log Logger instance
+ * @param uniqueKeysCache cache to save unique keys
  * @param filterAdapter filter adapter
- * @param cacheSize optional internal cache size
- * @param maxBulkSize optional max MTKs bulk size
  */
-export function uniqueKeysTrackerFactory(log, filterAdapter, cacheSize) {
+export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
-    if (cacheSize === void 0) { cacheSize = DEFAULT_CACHE_SIZE; }
-    var uniqueKeysTracker = {};
-    var uniqueTrackerSize = 0;
+    var intervalId;
+    if (filterAdapter.refreshRate) {
+        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+    }
     return {
-        track: function (featureName, key) {
-            if (!filterAdapter.add(featureName, key)) {
+        track: function (key, featureName) {
+            if (!filterAdapter.add(key, featureName)) {
                 log.debug(LOG_PREFIX_UNIQUE_KEYS_TRACKER + "The feature " + featureName + " and key " + key + " exist in the filter");
                 return;
             }
-            if (!uniqueKeysTracker[featureName])
-                uniqueKeysTracker[featureName] = new _Set();
-            var tracker = uniqueKeysTracker[featureName];
-            if (!tracker.has(key)) {
-                tracker.add(key);
-                log.debug(LOG_PREFIX_UNIQUE_KEYS_TRACKER + "Key " + key + " added to feature " + featureName);
-                uniqueTrackerSize++;
-            }
-            if (uniqueTrackerSize >= cacheSize) {
-                log.warn(LOG_PREFIX_UNIQUE_KEYS_TRACKER + "The UniqueKeysTracker size reached the maximum limit");
-                // @TODO trigger event to submitter to send mtk
-                uniqueTrackerSize = 0;
-            }
-        },
-        /**
-         * Pop the collected data, used as payload for posting.
-         */
-        pop: function () {
-            var data = uniqueKeysTracker;
-            uniqueKeysTracker = {};
-            return data;
-        },
-        /**
-         * Clear the data stored on the cache.
-         */
-        clear: function () {
-            uniqueKeysTracker = {};
+            uniqueKeysCache.track(key, featureName);
         },
-        /**
-         * Check if the cache is empty.
-         */
-        isEmpty: function () {
-            return Object.keys(uniqueKeysTracker).length === 0;
+        stop: function () {
+            clearInterval(intervalId);
         }
     };
 }

package/esm/utils/constants/index.js

@@ -38,6 +38,7 @@ 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/redis/RedisMock.js

@@ -0,0 +1,28 @@
+//@ts-nocheck
+function identityFunction(data) {
+    return data;
+}
+function asyncFunction(data) {
+    return Promise.resolve(data);
+}
+var IDENTITY_METHODS = [];
+var ASYNC_METHODS = ['rpush', 'hincrby'];
+var PIPELINE_METHODS = ['rpush', 'hincrby'];
+var RedisMock = /** @class */ (function () {
+    function RedisMock() {
+        var _this = this;
+        this.pipelineMethods = { exec: jest.fn(asyncFunction) };
+        IDENTITY_METHODS.forEach(function (method) {
+            _this[method] = jest.fn(identityFunction);
+        });
+        ASYNC_METHODS.forEach(function (method) {
+            _this[method] = jest.fn(asyncFunction);
+        });
+        PIPELINE_METHODS.forEach(function (method) {
+            _this.pipelineMethods[method] = _this[method];
+        });
+        this.pipeline = jest.fn(function () { return _this.pipelineMethods; });
+    }
+    return RedisMock;
+}());
+export { RedisMock };

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,7 +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.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.1",
+  "version": "1.6.2-rc.10",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -70,7 +70,6 @@
     "ioredis": "^4.28.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
-    "js-yaml": "^3.13.1",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.7",
     "redis-server": "1.2.2",

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();
-          if (impressionCounts) impressionCounts.clear();
+          if (impressions.clear) impressions.clear();// @ts-ignore
+          if (impressionCounts && impressionCounts.clear) 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,
@@ -68,28 +68,28 @@ export function evaluateFeatures(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
-  let stringifiedSplits;
+  let parsedSplits;
 
   try {
-    stringifiedSplits = storage.splits.getSplits(splitNames);
+    parsedSplits = storage.splits.getSplits(splitNames);
   } catch (e) {
     // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
     return treatmentsException(splitNames);
   }
 
-  return (thenable(stringifiedSplits)) ?
-    stringifiedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
+  return thenable(parsedSplits) ?
+    parsedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
       .catch(() => {
         // Exception on async `getSplits` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         return treatmentsException(splitNames);
       }) :
-    getEvaluations(log, splitNames, stringifiedSplits, key, attributes, storage);
+    getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
 }
 
 function getEvaluation(
   log: ILogger,
-  stringifiedSplit: string | null,
+  splitJSON: ISplit | null,
   key: SplitIO.SplitKey,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
@@ -100,8 +100,7 @@ function getEvaluation(
     config: null
   };
 
-  if (stringifiedSplit) {
-    const splitJSON: ISplit = JSON.parse(stringifiedSplit);
+  if (splitJSON) {
     const split = Engine.parse(log, splitJSON, storage);
     evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
@@ -125,7 +124,7 @@ function getEvaluation(
 function getEvaluations(
   log: ILogger,
   splitNames: string[],
-  splits: Record<string, string | null>,
+  splits: Record<string, ISplit | null>,
   key: SplitIO.SplitKey,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,

package/src/integrations/ga/GaToSplit.ts

@@ -12,6 +12,7 @@ import { SplitIO } from '../../types';
 import { Identity, GoogleAnalyticsToSplitOptions } from './types';
 import { ILogger } from '../../logger/types';
 import { IIntegrationFactoryParams } from '../types';
+import { ITelemetryTracker } from '../../trackers/types';
 
 const logPrefix = 'ga-to-split: ';
 const logNameMapper = 'ga-to-split:mapper';
@@ -25,7 +26,7 @@ const logNameMapper = 'ga-to-split:mapper';
  * @param log Logger instance.
  * @param autoRequire If true, log error when auto-require script is not detected
  */
-function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire?: boolean) {
+function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire: boolean, telemetryTracker?: ITelemetryTracker) {
   // get reference to global command queue. Init it if not defined yet.
   const gaAlias = window.GoogleAnalyticsObject || 'ga';
   window[gaAlias] = window[gaAlias] || function () {
@@ -35,10 +36,13 @@ function providePlugin(window: any, pluginName: string, pluginConstructor: Funct
   // provides the plugin for use with analytics.js.
   window[gaAlias]('provide', pluginName, pluginConstructor);
 
-  if (autoRequire && (!window[gaAlias].q || window[gaAlias].q.push === [].push)) {
-    // Expecting spy on ga.q push method but not found
+  const hasAutoRequire = window[gaAlias].q && window[gaAlias].q.push !== [].push;
+  if (autoRequire && !hasAutoRequire) { // Expecting spy on ga.q push method but not found
     log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run. Please check the docs.');
   }
+  if (telemetryTracker && hasAutoRequire) {
+    telemetryTracker.addTag('integration:ga-autorequire');
+  }
 }
 
 // Default mapping: object used for building the default mapper from hits to Split events
@@ -191,7 +195,7 @@ export function fixEventTypeId(log: ILogger, eventTypeId: any) {
  */
 export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIntegrationFactoryParams) {
 
-  const { storage, settings: { core: coreSettings, log } } = params;
+  const { storage, settings: { core: coreSettings, log }, telemetryTracker } = params;
 
   const defaultOptions = {
     prefix: defaultPrefix,
@@ -291,5 +295,5 @@ export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIn
   }
 
   // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
-  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true);
+  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true, telemetryTracker);
 }

package/src/integrations/types.ts

@@ -1,5 +1,5 @@
 import { IEventsCacheBase } from '../storages/types';
-import { IEventsHandler, IImpressionsHandler } from '../trackers/types';
+import { IEventsHandler, IImpressionsHandler, ITelemetryTracker } from '../trackers/types';
 import { ISettings, SplitIO } from '../types';
 
 export interface IIntegration {
@@ -11,6 +11,7 @@ export type IIntegrationManager = IEventsHandler & IImpressionsHandler;
 export interface IIntegrationFactoryParams {
   storage: { events: IEventsCacheBase }
   settings: ISettings
+  telemetryTracker: ITelemetryTracker
 }
 
 export type IntegrationFactory = {

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 } = params;
+  const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker, uniqueKeysTracker } = params;
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
@@ -39,6 +39,8 @@ 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();