@splitsoftware/splitio-commons 1.6.1 → 1.6.2-rc.2

package/cjs/utils/settingsValidation/impressionsMode.js

@@ -6,9 +6,9 @@ var constants_2 = require("../constants");
 var lang_1 = require("../lang");
 function validImpressionsMode(log, impressionsMode) {
     impressionsMode = (0, lang_1.stringToUpperCase)(impressionsMode);
-    if ([constants_2.DEBUG, constants_2.OPTIMIZED].indexOf(impressionsMode) > -1)
+    if ([constants_2.DEBUG, constants_2.OPTIMIZED, constants_2.NONE].indexOf(impressionsMode) > -1)
         return impressionsMode;
-    log.error(constants_1.ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [constants_2.DEBUG, constants_2.OPTIMIZED], constants_2.OPTIMIZED]);
+    log.error(constants_1.ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [constants_2.DEBUG, constants_2.OPTIMIZED, constants_2.NONE], constants_2.OPTIMIZED]);
     return constants_2.OPTIMIZED;
 }
 exports.validImpressionsMode = validImpressionsMode;

package/cjs/utils/settingsValidation/index.js

@@ -34,6 +34,8 @@ exports.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
@@ -112,6 +114,7 @@ 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 ((0, lang_1.get)(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === constants_1.DEBUG)

package/esm/listeners/browser.js

@@ -1,6 +1,6 @@
 import { fromImpressionsCollector } from '../sync/submitters/impressionsSubmitter';
 import { fromImpressionCountsCollector } from '../sync/submitters/impressionCountsSubmitter';
-import { OPTIMIZED, DEBUG } from '../utils/constants';
+import { OPTIMIZED, DEBUG, NONE } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
@@ -71,9 +71,10 @@ var BrowserSignalListener = /** @class */ (function () {
         // Flush impressions & events data if there is user consent
         if (isConsentGranted(this.settings)) {
             var eventsUrl = this.settings.urls.events;
+            var sim = this.settings.sync.impressionsMode;
             var extraMetadata = {
                 // sim stands for Sync/Split Impressions Mode
-                sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
+                sim: sim === OPTIMIZED ? OPTIMIZED : sim === DEBUG ? DEBUG : NONE
             };
             this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
             this._flushData(eventsUrl + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);

package/esm/logger/constants.js

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

package/esm/sdkFactory/index.js

@@ -10,11 +10,16 @@ import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
 import { metadataBuilder } from '../storages/metadataBuilder';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
+import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
+import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
+import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
+import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
+import { NONE } from '../utils/constants';
 /**
  * Modular SDK factory
  */
 export function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory;
     var log = settings.log;
     // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid API Key, etc.
     // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
@@ -26,12 +31,14 @@ export function sdkFactory(params) {
     var storageFactoryParams = {
         impressionsQueueSize: settings.scheduler.impressionsQueueSize,
         eventsQueueSize: settings.scheduler.eventsQueueSize,
+        uniqueKeysCacheSize: settings.scheduler.uniqueKeysCacheSize,
         optimize: shouldBeOptimized(settings),
         // ATM, only used by InLocalStorage
         matchingKey: getMatching(settings.core.key),
         splitFiltersValidation: settings.sync.__splitFiltersValidation,
         // ATM, only used by PluggableStorage
         mode: settings.mode,
+        impressionsMode: settings.sync.impressionsMode,
         // Callback used to emit SDK_READY in consumer mode, where `syncManagerFactory` is undefined,
         // or partial consumer mode, where it only has submitters, and therefore it doesn't emit readiness events.
         onReadyCb: function (error) {
@@ -46,14 +53,16 @@ export function sdkFactory(params) {
     var storage = storageFactory(storageFactoryParams);
     // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage });
-    // trackers
-    var observer = impressionsObserverFactory && impressionsObserverFactory();
-    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts, storage.telemetry);
+    var observer = impressionsObserverFactory();
+    var uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory()) : undefined;
+    var strategy = (storageFactoryParams.optimize) ? strategyOptimizedFactory(observer, storage.impressionCounts) :
+        (storageFactoryParams.impressionsMode === NONE) ? strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker) : strategyDebugFactory(observer);
+    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
     var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
+    var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);

package/esm/services/splitApi.js

@@ -87,6 +87,26 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             var url = urls.events + "/testImpressions/count";
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
         },
+        /**
+         * Post unique keys for client side.
+         *
+         * @param body  unique keys payload
+         * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
+         */
+        postUniqueKeysBulkCs: function (body, headers) {
+            var url = urls.telemetry + "/v1/keys/cs";
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
+        },
+        /**
+         * Post unique keys for server side.
+         *
+         * @param body  unique keys payload
+         * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
+         */
+        postUniqueKeysBulkSs: function (body, headers) {
+            var url = urls.telemetry + "/v1/keys/ss";
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
+        },
         postMetricsConfig: function (body) {
             var url = urls.telemetry + "/v1/metrics/config";
             return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(TELEMETRY), true);

package/esm/storages/inLocalStorage/index.js

@@ -11,8 +11,9 @@ import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
-import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { LOCALHOST_MODE, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemoryCS } from '../inMemory/uniqueKeysCacheInMemoryCS';
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -35,12 +36,15 @@ export function InLocalStorage(options) {
             impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
             events: new EventsCacheInMemory(params.eventsQueueSize),
             telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
+            uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
             destroy: function () {
+                var _a;
                 this.splits = new SplitsCacheInMemory();
                 this.segments = new MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
                 this.events.clear();
+                (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
             },
             // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {

package/esm/storages/inMemory/InMemoryStorage.js

@@ -3,8 +3,9 @@ import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
+import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemory } from './uniqueKeysCacheInMemory';
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
@@ -15,16 +16,19 @@ export function InMemoryStorageFactory(params) {
         splits: new SplitsCacheInMemory(),
         segments: new SegmentsCacheInMemory(),
         impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
+        impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory(params.eventsQueueSize),
         telemetry: params.mode !== LOCALHOST_MODE ? new TelemetryCacheInMemory() : undefined,
+        uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemory(params.uniqueKeysCacheSize) : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
+            var _a;
             this.splits.clear();
             this.segments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
+            (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
         }
     };
 }

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -3,8 +3,9 @@ import { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
+import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemoryCS } from './uniqueKeysCacheInMemoryCS';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
@@ -15,16 +16,19 @@ export function InMemoryStorageCSFactory(params) {
         splits: new SplitsCacheInMemory(),
         segments: new MySegmentsCacheInMemory(),
         impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
+        impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory(params.eventsQueueSize),
         telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
+        uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS(params.uniqueKeysCacheSize) : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
+            var _a;
             this.splits.clear();
             this.segments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
+            (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
         },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {

package/esm/storages/inMemory/uniqueKeysCacheInMemory.js

@@ -0,0 +1,70 @@
+import { setToArray, _Set } from '../../utils/lang/sets';
+var DEFAULT_CACHE_SIZE = 30000;
+var UniqueKeysCacheInMemory = /** @class */ (function () {
+    function UniqueKeysCacheInMemory(uniqueKeysQueueSize) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        this.uniqueTrackerSize = 0;
+        this.maxStorage = uniqueKeysQueueSize;
+        this.uniqueKeysTracker = {};
+    }
+    UniqueKeysCacheInMemory.prototype.setOnFullQueueCb = function (cb) {
+        this.onFullQueue = cb;
+    };
+    /**
+     * Store unique keys in sequential order
+     * key: string = feature name.
+     * value: Set<string> = set of unique keys.
+     */
+    UniqueKeysCacheInMemory.prototype.track = function (key, featureName) {
+        if (!this.uniqueKeysTracker[featureName])
+            this.uniqueKeysTracker[featureName] = new _Set();
+        var tracker = this.uniqueKeysTracker[featureName];
+        if (!tracker.has(key)) {
+            tracker.add(key);
+            this.uniqueTrackerSize++;
+        }
+        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+            this.uniqueTrackerSize = 0;
+            this.onFullQueue();
+        }
+    };
+    /**
+     * Clear the data stored on the cache.
+     */
+    UniqueKeysCacheInMemory.prototype.clear = function () {
+        this.uniqueKeysTracker = {};
+    };
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    UniqueKeysCacheInMemory.prototype.pop = function () {
+        var data = this.uniqueKeysTracker;
+        this.uniqueKeysTracker = {};
+        return this.fromUniqueKeysCollector(data);
+    };
+    /**
+     * Check if the cache is empty.
+     */
+    UniqueKeysCacheInMemory.prototype.isEmpty = function () {
+        return Object.keys(this.uniqueKeysTracker).length === 0;
+    };
+    /**
+     * Converts `uniqueKeys` data from cache into request payload for SS.
+     */
+    UniqueKeysCacheInMemory.prototype.fromUniqueKeysCollector = function (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 };
+    };
+    return UniqueKeysCacheInMemory;
+}());
+export { UniqueKeysCacheInMemory };

package/esm/storages/inMemory/uniqueKeysCacheInMemoryCS.js

@@ -0,0 +1,75 @@
+import { setToArray, _Set } from '../../utils/lang/sets';
+var DEFAULT_CACHE_SIZE = 30000;
+var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
+    /**
+     *
+     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+     */
+    function UniqueKeysCacheInMemoryCS(uniqueKeysQueueSize) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = DEFAULT_CACHE_SIZE; }
+        this.uniqueTrackerSize = 0;
+        this.maxStorage = uniqueKeysQueueSize;
+        this.uniqueKeysTracker = {};
+    }
+    UniqueKeysCacheInMemoryCS.prototype.setOnFullQueueCb = function (cb) {
+        this.onFullQueue = cb;
+    };
+    /**
+     * Store unique keys in sequential order
+     * key: string = key.
+     * value: HashSet<string> = set of split names.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.track = function (key, featureName) {
+        if (!this.uniqueKeysTracker[key])
+            this.uniqueKeysTracker[key] = new _Set();
+        var tracker = this.uniqueKeysTracker[key];
+        if (!tracker.has(featureName)) {
+            tracker.add(featureName);
+            this.uniqueTrackerSize++;
+        }
+        if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+            this.uniqueTrackerSize = 0;
+            this.onFullQueue();
+        }
+    };
+    /**
+     * Clear the data stored on the cache.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.clear = function () {
+        this.uniqueKeysTracker = {};
+    };
+    /**
+     * Pop the collected data, used as payload for posting.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.pop = function () {
+        var data = this.uniqueKeysTracker;
+        this.uniqueKeysTracker = {};
+        return this.fromUniqueKeysCollector(data);
+    };
+    /**
+     * Check if the cache is empty.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.isEmpty = function () {
+        return Object.keys(this.uniqueKeysTracker).length === 0;
+    };
+    /**
+     * Converts `uniqueKeys` data from cache into request payload.
+     */
+    UniqueKeysCacheInMemoryCS.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
+        var payload = [];
+        var featureKeys = Object.keys(uniqueKeys);
+        for (var k = 0; k < featureKeys.length; k++) {
+            var featureKey = featureKeys[k];
+            var featureNames = setToArray(uniqueKeys[featureKey]);
+            var uniqueKeysPayload = {
+                k: featureKey,
+                fs: featureNames
+            };
+            payload.push(uniqueKeysPayload);
+        }
+        return { keys: payload };
+    };
+    return UniqueKeysCacheInMemoryCS;
+}());
+export { UniqueKeysCacheInMemoryCS };

package/esm/sync/submitters/submitterManager.js

@@ -2,6 +2,7 @@ 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),
@@ -11,6 +12,8 @@ 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,6 +1,6 @@
 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';
@@ -46,6 +46,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,

package/esm/sync/submitters/uniqueKeysSubmitter.js

@@ -0,0 +1,22 @@
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+import { submitterFactory } from './submitter';
+var DATA_NAME = 'uniqueKeys';
+/**
+ * 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 isClientSide = key !== undefined;
+    var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
+    var syncTask = submitterFactory(log, postUniqueKeysBulk, uniqueKeys, uniqueKeysRefreshRate, 'unique keys');
+    // 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

@@ -1,6 +1,5 @@
 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';
 /**
@@ -10,37 +9,17 @@ 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 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)
+ * @param strategy strategy for impressions tracking.
  */
-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) {
+export function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, 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 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);
-                }
-                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 _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)) {
@@ -55,7 +34,7 @@ countsCache, telemetryCache) {
                 // @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);
+                    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
@@ -63,7 +42,7 @@ countsCache, telemetryCache) {
                 var _loop_1 = function (i) {
                     var impressionData = {
                         // copy of impression, to avoid unexpected behaviour if modified by integrations or impressionListener
-                        impression: objectAssign({}, impressions[i]),
+                        impression: objectAssign({}, impressionsToListener[i]),
                         attributes: attributes,
                         ip: ip,
                         hostname: hostname,
@@ -83,7 +62,7 @@ countsCache, telemetryCache) {
                         }
                     }, 0);
                 };
-                for (var i = 0; i < impressionsCount; i++) {
+                for (var i = 0; i < impressionsToListenerCount; i++) {
                     _loop_1(i);
                 }
             }

package/esm/trackers/strategy/strategyDebug.js

@@ -0,0 +1,21 @@
+/**
+ * Debug strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
+ *
+ * @param impressionsObserver impression observer. Previous time (pt property) is included in impression instances
+ * @returns IStrategyResult
+ */
+export function strategyDebugFactory(impressionsObserver) {
+    return {
+        process: function (impressions) {
+            impressions.forEach(function (impression) {
+                // Adds previous time if it is enabled
+                impression.pt = impressionsObserver.testAndSet(impression);
+            });
+            return {
+                impressionsToStore: impressions,
+                impressionsToListener: impressions,
+                deduped: 0
+            };
+        }
+    };
+}

package/esm/trackers/strategy/strategyNone.js

@@ -0,0 +1,25 @@
+/**
+ * None strategy for impressions tracker.
+ *
+ * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
+ * @param uniqueKeysTracker unique keys tracker in charge of tracking the unique keys per split.
+ * @returns IStrategyResult
+ */
+export function strategyNoneFactory(impressionsCounter, uniqueKeysTracker) {
+    return {
+        process: function (impressions) {
+            impressions.forEach(function (impression) {
+                var now = Date.now();
+                // Increments impression counter per featureName
+                impressionsCounter.track(impression.feature, now, 1);
+                // Keep track by unique key
+                uniqueKeysTracker.track(impression.keyName, impression.feature);
+            });
+            return {
+                impressionsToStore: [],
+                impressionsToListener: impressions,
+                deduped: 0
+            };
+        }
+    };
+}

package/esm/trackers/strategy/strategyOptimized.js

@@ -0,0 +1,30 @@
+import { truncateTimeFrame } from '../../utils/time';
+/**
+ * Optimized strategy for impressions tracker. Wraps impressions to store and adds previousTime if it corresponds
+ *
+ * @param impressionsObserver impression observer. previous time (pt property) is included in impression instances
+ * @param impressionsCounter cache to save impressions count. impressions will be deduped (OPTIMIZED mode)
+ * @returns IStrategyResult
+ */
+export function strategyOptimizedFactory(impressionsObserver, impressionsCounter) {
+    return {
+        process: function (impressions) {
+            var impressionsToStore = [];
+            impressions.forEach(function (impression) {
+                impression.pt = impressionsObserver.testAndSet(impression);
+                var now = Date.now();
+                // Increments impression counter per featureName
+                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);
+                }
+            });
+            return {
+                impressionsToStore: impressionsToStore,
+                impressionsToListener: impressions,
+                deduped: impressions.length - impressionsToStore.length
+            };
+        }
+    };
+}

package/esm/trackers/uniqueKeysTracker.js

@@ -0,0 +1,27 @@
+import { LOG_PREFIX_UNIQUE_KEYS_TRACKER } from '../logger/constants';
+var noopFilterAdapter = {
+    add: function () { return true; },
+    contains: function () { return true; },
+    clear: function () { }
+};
+/**
+ * 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 filterAdapter filter adapter
+ * @param uniqueKeysCache cache to save unique keys
+ */
+export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
+    if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
+    return {
+        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;
+            }
+            uniqueKeysCache.track(key, featureName);
+        }
+    };
+}

package/esm/utils/constants/index.js

@@ -13,6 +13,7 @@ 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';
@@ -37,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';