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

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,52 +9,34 @@ 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 _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 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);
+                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
@@ -63,7 +44,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 +64,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,31 @@
+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
+                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);
+                }
+            });
+            return {
+                impressionsToStore: impressionsToStore,
+                impressionsToListener: impressions,
+                deduped: impressions.length - impressionsToStore.length
+            };
+        }
+    };
+}

package/esm/trackers/uniqueKeysTracker.js

@@ -0,0 +1,34 @@
+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 uniqueKeysCache cache to save unique keys
+ * @param filterAdapter filter adapter
+ */
+export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
+    if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
+    var intervalId;
+    if (filterAdapter.refreshRate) {
+        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+    }
+    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);
+        },
+        stop: function () {
+            clearInterval(intervalId);
+        }
+    };
+}

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';

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/impressionsMode.js

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

package/esm/utils/settingsValidation/index.js

@@ -23,8 +23,8 @@ export var base = {
         IPAddressesEnabled: undefined
     },
     scheduler: {
-        // fetch feature updates each 30 sec
-        featuresRefreshRate: 30,
+        // fetch feature updates each 60 sec
+        featuresRefreshRate: 60,
         // fetch segments updates each 60 sec
         segmentsRefreshRate: 60,
         // publish telemetry stats each 3600 secs (1 hour)
@@ -129,8 +129,8 @@ export function settingsValidation(config, validationParams) {
     if (storage)
         withDefaults.storage = storage(withDefaults);
     // Validate key and TT (for client-side)
+    var maybeKey = withDefaults.core.key;
     if (validationParams.acceptKey) {
-        var maybeKey = withDefaults.core.key;
         // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
         if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {
             withDefaults.core.key = 'localhost_key';
@@ -148,6 +148,12 @@ export function settingsValidation(config, validationParams) {
             }
         }
     }
+    else {
+        // On server-side, key is undefined and used to distinguish from client-side
+        if (maybeKey !== undefined)
+            log.warn('Provided `key` is ignored in server-side SDK.'); // @ts-ignore
+        withDefaults.core.key = undefined;
+    }
     // Current ip/hostname information
     // @ts-ignore, modify readonly prop
     withDefaults.runtime = runtime(withDefaults);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.9",
+  "version": "1.7.1",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -71,7 +71,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/listeners/browser.ts

@@ -1,18 +1,17 @@
 /* eslint-disable no-undef */
 // @TODO eventually migrate to JS-Browser-SDK package.
 import { ISignalListener } from './types';
-import { IRecorderCacheProducerSync, IStorageSync } from '../storages/types';
+import { IRecorderCacheSync, IStorageSync } from '../storages/types';
 import { fromImpressionsCollector } from '../sync/submitters/impressionsSubmitter';
 import { fromImpressionCountsCollector } from '../sync/submitters/impressionCountsSubmitter';
 import { IResponse, ISplitApi } from '../services/types';
 import { ImpressionDTO, ISettings } from '../types';
 import { ImpressionsPayload } from '../sync/submitters/types';
-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 { ISyncManager } from '../sync/types';
 import { isConsentGranted } from '../consent';
-import { telemetryCacheStatsAdapter } from '../sync/submitters/telemetrySubmitter';
 
 const VISIBILITYCHANGE_EVENT = 'visibilitychange';
 const PAGEHIDE_EVENT = 'pagehide';
@@ -84,26 +83,25 @@ export class BrowserSignalListener implements ISignalListener {
    */
   flushData() {
     if (!this.syncManager) return; // In consumer mode there is not sync manager and data to flush
+    const { events, telemetry } = this.settings.urls;
 
     // 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: 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);
-      if (this.storage.impressionCounts) this._flushData(eventsUrl + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);
+      this._flushData(events + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
+      this._flushData(events + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
+      if (this.storage.impressionCounts) this._flushData(events + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);
+      // @ts-ignore
+      if (this.storage.uniqueKeys) this._flushData(telemetry + '/v1/keys/cs/beacon', this.storage.uniqueKeys, this.serviceApi.postUniqueKeysBulkCs);
     }
 
     // Flush telemetry data
-    if (this.storage.telemetry) {
-      const telemetryUrl = this.settings.urls.telemetry;
-      const telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
-      this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
-    }
+    if (this.storage.telemetry) this._flushData(telemetry + '/v1/metrics/usage/beacon', this.storage.telemetry, this.serviceApi.postMetricsUsage);
   }
 
   flushDataIfHidden() {
@@ -111,14 +109,13 @@ export class BrowserSignalListener implements ISignalListener {
     if (document.visibilityState === 'hidden') this.flushData(); // On a 'visibilitychange' event, flush data if state is hidden
   }
 
-  private _flushData<T>(url: string, cache: IRecorderCacheProducerSync<T>, postService: (body: string) => Promise<IResponse>, fromCacheToPayload?: (cacheData: T) => any, extraMetadata?: {}) {
+  private _flushData<T>(url: string, cache: IRecorderCacheSync<T>, postService: (body: string) => Promise<IResponse>, fromCacheToPayload?: (cacheData: T) => any, extraMetadata?: {}) {
     // if there is data in cache, send it to backend
     if (!cache.isEmpty()) {
       const dataPayload = fromCacheToPayload ? fromCacheToPayload(cache.pop()) : cache.pop();
       if (!this._sendBeacon(url, dataPayload, extraMetadata)) {
         postService(JSON.stringify(dataPayload)).catch(() => { }); // no-op just to catch a possible exception
       }
-      cache.clear();
     }
   }
 

package/src/logger/constants.ts

@@ -143,4 +143,5 @@ 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/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
@@ -40,6 +40,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();
         });

package/src/sdkFactory/index.ts

@@ -3,16 +3,17 @@ import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
 import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import { IStorageFactoryParams } from '../storages/types';
 import { SplitIO } from '../types';
-import { getMatching } from '../utils/key';
-import { shouldBeOptimized } from '../trackers/impressionObserver/utils';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 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, OPTIMIZED } from '../utils/constants';
 
 /**
  * Modular SDK factory
@@ -21,8 +22,9 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
-    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory } = params;
-  const log = settings.log;
+    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
+    filterAdapterFactory } = params;
+  const { log, sync: { impressionsMode } } = settings;
 
   // @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.
@@ -33,45 +35,41 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
   const readiness = sdkReadinessManager.readinessManager;
 
-  // @TODO consider passing the settings object, so that each storage access only what it needs
-  const storageFactoryParams: IStorageFactoryParams = {
-    impressionsQueueSize: settings.scheduler.impressionsQueueSize,
-    eventsQueueSize: settings.scheduler.eventsQueueSize,
-    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,
-
-    // 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.
+  const storage = storageFactory({
+    settings,
     onReadyCb: (error) => {
       if (error) return; // Don't emit SDK_READY if storage failed to connect. Error message is logged by wrapperAdapter
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
-    metadata: metadataBuilder(settings),
-    log
-  };
-
-  const storage = storageFactory(storageFactoryParams);
+  });
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
 
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
-  // trackers
-  const observer = impressionsObserverFactory && impressionsObserverFactory();
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts, storage.telemetry);
+  const observer = impressionsObserverFactory();
+  const uniqueKeysTracker = impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
+
+  let strategy;
+  switch (impressionsMode) {
+    case OPTIMIZED:
+      strategy = strategyOptimizedFactory(observer, storage.impressionCounts!);
+      break;
+    case NONE:
+      strategy = strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!);
+      break;
+    default:
+      strategy = strategyDebugFactory(observer);
+  }
+
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
   const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, sdkReadinessManager, readiness, settings, storage, platform };
+  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
 
   const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
   ctx.syncManager = syncManager;
@@ -100,7 +98,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     },
 
     // Logger wrapper API
-    Logger: createLoggerAPI(settings.log),
+    Logger: createLoggerAPI(log),
 
     settings,
   }, extraProps && extraProps(ctx));

package/src/sdkFactory/types.ts

@@ -6,7 +6,7 @@ import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
 
 /**
@@ -44,6 +44,7 @@ export interface ISdkFactoryContext {
   eventTracker: IEventTracker,
   telemetryTracker: ITelemetryTracker,
   storage: IStorageSync | IStorageAsync,
+  uniqueKeysTracker?: IUniqueKeysTracker,
   signalListener?: ISignalListener
   splitApi?: ISplitApi
   syncManager?: ISyncManager,
@@ -96,6 +97,11 @@ export interface ISdkFactoryParams {
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).
   sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
 
+  // Impression observer factory.
+  impressionsObserverFactory: () => IImpressionObserver
+
+  filterAdapterFactory?: () => IFilterAdapter
+
   // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.
   // Pass only if `syncManager` (used by Node listener) and `splitApi` (used by Browser listener) are passed.
   SignalListener?: new (
@@ -107,9 +113,6 @@ export interface ISdkFactoryParams {
   // @TODO review impressionListener and integrations interfaces. What about handling impressionListener as an integration ?
   integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined,
 
-  // Impression observer factory. If provided, will be used for impressions dedupe
-  impressionsObserverFactory?: () => IImpressionObserver
-
   // Optional function to assign additional properties to the factory instance
   extraProps?: (params: ISdkFactoryContext) => object
 }

package/src/services/splitApi.ts

@@ -107,6 +107,28 @@ export function splitApiFactory(
       return splitHttpClient(url, { method: 'POST', body, 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(body: string, headers?: Record<string, string>) {
+      const url = `${urls.telemetry}/v1/keys/cs`;
+      return splitHttpClient(url, { method: 'POST', body, 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(body: string, headers?: Record<string, string>) {
+      const url = `${urls.telemetry}/v1/keys/ss`;
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
+    },
+
     postMetricsConfig(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/v1/metrics/config`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);

package/src/services/types.ts

@@ -43,6 +43,10 @@ export type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => P
 
 export type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
+export type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>
+
+export type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>
+
 export type IPostTestImpressionsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
 export type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>
@@ -59,6 +63,8 @@ export interface ISplitApi {
 	fetchSegmentChanges: IFetchSegmentChanges
 	fetchMySegments: IFetchMySegments
 	postEventsBulk: IPostEventsBulk
+	postUniqueKeysBulkCs: IPostUniqueKeysBulkCs
+	postUniqueKeysBulkSs: IPostUniqueKeysBulkSs
 	postTestImpressionsBulk: IPostTestImpressionsBulk
 	postTestImpressionsCount: IPostTestImpressionsCount
 	postMetricsConfig: IPostMetricsConfig

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -41,7 +41,7 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
    * @param {string} name
    * @param {string} defaultTreatment
    * @param {number} changeNumber
-   * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated,
+   * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
    * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
    * The promise will never be rejected.
    */