@splitsoftware/splitio-commons 1.2.1-rc.3 → 1.2.1-rc.6

package/esm/sync/syncManagerOnline.js

@@ -1,6 +1,7 @@
 import { submitterManagerFactory } from './submitters/submitterManager';
 import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
+import { isConsentGranted } from '../utils/consent';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -14,7 +15,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
      * SyncManager factory for modular SDK
      */
     return function (params) {
-        var _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled;
+        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled;
         /** Polling Manager */
         var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
@@ -49,11 +50,16 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
         var running = false; // flag that indicates whether the syncManager has been started (true) or stopped (false)
         var startFirstTime = true; // flag to distinguish calling the `start` method for the first time, to support pausing and resuming the synchronization
         return {
+            // Exposed for fine-grained control of synchronization.
+            // E.g.: user consent, app state changes (Page hide, Foreground/Background, Online/Offline).
+            pollingManager: pollingManager,
             pushManager: pushManager,
+            submitter: submitter,
             /**
              * Method used to start the syncManager for the first time, or resume it after being stopped.
              */
             start: function () {
+                running = true;
                 // start syncing splits and segments
                 if (pollingManager) {
                     if (pushManager) {
@@ -69,29 +75,27 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                     }
                 }
                 // start periodic data recording (events, impressions, telemetry).
-                if (submitter)
+                if (isConsentGranted(settings))
                     submitter.start();
-                running = true;
             },
             /**
              * Method used to stop/pause the syncManager.
              */
             stop: function () {
+                running = false;
                 // stop syncing
                 if (pushManager)
                     pushManager.stop();
                 if (pollingManager && pollingManager.isRunning())
                     pollingManager.stop();
                 // stop periodic data recording (events, impressions, telemetry).
-                if (submitter)
-                    submitter.stop();
-                running = false;
+                submitter.stop();
             },
             isRunning: function () {
                 return running;
             },
             flush: function () {
-                if (submitter)
+                if (isConsentGranted(settings))
                     return submitter.execute();
                 else
                     return Promise.resolve();

package/esm/utils/consent.js

@@ -0,0 +1,6 @@
+import { CONSENT_GRANTED } from './constants';
+export function isConsentGranted(settings) {
+    var userConsent = settings.userConsent;
+    // undefined userConsent is handled as granted (default)
+    return !userConsent || userConsent === CONSENT_GRANTED;
+}

package/esm/utils/constants/index.js

@@ -24,3 +24,7 @@ export var STORAGE_MEMORY = 'MEMORY';
 export var STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';
 export var STORAGE_REDIS = 'REDIS';
 export var STORAGE_PLUGGABLE = 'PLUGGABLE';
+// User consent
+export var CONSENT_GRANTED = 'GRANTED'; // The user has granted consent for tracking events and impressions
+export var CONSENT_DECLINED = 'DECLINED'; // The user has declined consent for tracking events and impressions
+export var CONSENT_UNKNOWN = 'UNKNOWN'; // The user has neither granted nor declined consent for tracking events and impressions

package/esm/utils/lang/index.js

@@ -152,6 +152,12 @@ export function isObject(obj) {
 export function isString(val) {
     return typeof val === 'string' || val instanceof String;
 }
+/**
+ * String sanitizer. Returns the provided value converted to uppercase if it is a string.
+ */
+export function stringToUpperCase(val) {
+    return isString(val) ? val.toUpperCase() : val;
+}
 /**
  * Deep copy version of Object.assign using recursion.
  * There are some assumptions here. It's for internal use and we don't need verbose errors

package/esm/utils/settingsValidation/consent.js

@@ -0,0 +1,12 @@
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
+import { CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN } from '../constants';
+import { stringToUpperCase } from '../lang';
+var userConsentValues = [CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN];
+export function validateConsent(_a) {
+    var userConsent = _a.userConsent, log = _a.log;
+    userConsent = stringToUpperCase(userConsent);
+    if (userConsentValues.indexOf(userConsent) > -1)
+        return userConsent;
+    log.error(ERROR_INVALID_CONFIG_PARAM, ['userConsent', userConsentValues, CONSENT_GRANTED]);
+    return CONSENT_GRANTED;
+}

package/esm/utils/settingsValidation/impressionsMode.js

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

package/esm/utils/settingsValidation/index.js

@@ -33,6 +33,8 @@ var base = {
         eventsPushRate: 60,
         // how many events will be queued before flushing
         eventsQueueSize: 500,
+        // how many impressions will be queued before flushing
+        impressionsQueueSize: 30000,
         // backoff base seconds to wait before re attempting to connect to push notifications
         pushRetryBackoffBase: 1,
     },
@@ -78,7 +80,7 @@ function fromSecondsToMillis(n) {
  * @param validationParams defaults and fields validators used to validate and creates a settings object from a given config
  */
 export function settingsValidation(config, validationParams) {
-    var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger, localhost = validationParams.localhost;
+    var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger, localhost = validationParams.localhost, consent = validationParams.consent;
     // creates a settings object merging base, defaults and config objects.
     var withDefaults = merge({}, base, defaults, config);
     // ensure a valid logger.
@@ -131,5 +133,8 @@ export function settingsValidation(config, validationParams) {
     withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
     // ensure a valid impressionsMode
     withDefaults.sync.impressionsMode = validImpressionsMode(log, withDefaults.sync.impressionsMode);
+    // ensure a valid user consent value
+    // @ts-ignore, modify readonly prop
+    withDefaults.userConsent = consent(withDefaults);
     return withDefaults;
 }

package/esm/utils/settingsValidation/{runtime/browser.js → runtime.js}

@@ -1,3 +1,4 @@
+// For client-side SDKs, machine IP and Hostname are not captured and sent to Split backend.
 export function validateRuntime() {
     return {
         ip: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.2.1-rc.3",
+  "version": "1.2.1-rc.6",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -49,7 +49,6 @@
   "devDependencies": {
     "@types/google.analytics": "0.0.40",
     "@types/ioredis": "^4.28.0",
-    "@types/ip": "^1.1.0",
     "@types/jest": "^27.0.0",
     "@types/lodash": "^4.14.162",
     "@typescript-eslint/eslint-plugin": "^4.2.0",

package/src/listeners/browser.ts

@@ -11,6 +11,7 @@ import { OPTIMIZED, DEBUG } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
+import { isConsentGranted } from '../utils/consent';
 
 // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
 const UNLOAD_DOM_EVENT = 'unload';
@@ -65,15 +66,18 @@ export class BrowserSignalListener implements ISignalListener {
   flushData() {
     if (!this.syncManager) return; // In consumer mode there is not sync manager and data to flush
 
-    const eventsUrl = this.settings.urls.events;
-    const extraMetadata = {
-      // sim stands for Sync/Split Impressions Mode
-      sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
-    };
+    // Flush data if there is user consent
+    if (isConsentGranted(this.settings)) {
+      const eventsUrl = this.settings.urls.events;
+      const extraMetadata = {
+        // sim stands for Sync/Split Impressions Mode
+        sim: this.settings.sync.impressionsMode === OPTIMIZED ? OPTIMIZED : DEBUG
+      };
 
-    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(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);
+    }
 
     // Close streaming connection
     if (this.syncManager.pushManager) this.syncManager.pushManager.stop();
@@ -84,7 +88,7 @@ export class BrowserSignalListener implements ISignalListener {
     if (!cache.isEmpty()) {
       const dataPayload = fromCacheToPayload ? fromCacheToPayload(cache.state()) : cache.state();
       if (!this._sendBeacon(url, dataPayload, extraMetadata)) {
-        postService(JSON.stringify(dataPayload)).catch(() => { }); // no-op just to catch a possible exceptions
+        postService(JSON.stringify(dataPayload)).catch(() => { }); // no-op just to catch a possible exception
       }
       cache.clear();
     }

package/src/logger/constants.ts

@@ -61,13 +61,15 @@ export const STREAMING_RECONNECT = 111;
 export const STREAMING_CONNECTING = 112;
 export const STREAMING_DISABLED = 113;
 export const STREAMING_DISCONNECTING = 114;
-export const SUBMITTERS_PUSH_FULL_EVENTS_QUEUE = 115;
+export const SUBMITTERS_PUSH_FULL_QUEUE = 115;
 export const SUBMITTERS_PUSH = 116;
 export const SYNC_START_POLLING = 117;
 export const SYNC_CONTINUE_POLLING = 118;
 export const SYNC_STOP_POLLING = 119;
 export const EVENTS_TRACKER_SUCCESS = 120;
 export const IMPRESSIONS_TRACKER_SUCCESS = 121;
+export const USER_CONSENT_UPDATED = 122;
+export const USER_CONSENT_NOT_UPDATED = 123;
 
 export const ENGINE_VALUE_INVALID = 200;
 export const ENGINE_VALUE_NO_ATTRIBUTES = 201;
@@ -115,10 +117,11 @@ export const ERROR_INVALID_KEY_OBJECT = 317;
 export const ERROR_INVALID = 318;
 export const ERROR_EMPTY = 319;
 export const ERROR_EMPTY_ARRAY = 320;
-export const ERROR_INVALID_IMPRESSIONS_MODE = 321;
+export const ERROR_INVALID_CONFIG_PARAM = 321;
 export const ERROR_HTTP = 322;
 export const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export const ERROR_STORAGE_INVALID = 324;
+export const ERROR_NOT_BOOLEAN = 325;
 
 // Log prefixes (a.k.a. tags or categories)
 export const LOG_PREFIX_SETTINGS = 'settings';

package/src/logger/messages/debug.ts

@@ -31,9 +31,9 @@ export const codesDebug: [number, string][] = codesInfo.concat([
   // SDK
   [c.CLEANUP_REGISTERING, c.LOG_PREFIX_CLEANUP + 'Registering cleanup handler %s'],
   [c.CLEANUP_DEREGISTERING, c.LOG_PREFIX_CLEANUP + 'Deregistering cleanup handler %s'],
-  [c.RETRIEVE_CLIENT_DEFAULT, ' Retrieving default SDK client.'],
-  [c.RETRIEVE_CLIENT_EXISTING, ' Retrieving existing SDK client.'],
-  [c.RETRIEVE_MANAGER, ' Retrieving manager instance.'],
+  [c.RETRIEVE_CLIENT_DEFAULT, 'Retrieving default SDK client.'],
+  [c.RETRIEVE_CLIENT_EXISTING, 'Retrieving existing SDK client.'],
+  [c.RETRIEVE_MANAGER, 'Retrieving manager instance.'],
   // synchronizer
   [c.SYNC_OFFLINE_DATA, c.LOG_PREFIX_SYNC_OFFLINE + 'Splits data: \n%s'],
   [c.SYNC_SPLITS_FETCH, c.LOG_PREFIX_SYNC_SPLITS + 'Spin up split update using since = %s'],

package/src/logger/messages/error.ts

@@ -5,7 +5,7 @@ export const codesError: [number, string][] = [
   [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid Split, no valid rules found'],
   // SDK
   [c.ERROR_LOGLEVEL_INVALID, 'logger: Invalid Log Level - No changes to the logs will be applied.'],
-  [c.ERROR_CLIENT_CANNOT_GET_READY, ' The SDK will not get ready. Reason: %s'],
+  [c.ERROR_CLIENT_CANNOT_GET_READY, 'The SDK will not get ready. Reason: %s'],
   [c.ERROR_IMPRESSIONS_TRACKER, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Could not store impressions bulk with %s impression(s). Error: %s'],
   [c.ERROR_IMPRESSIONS_LISTENER, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Impression listener logImpression method threw: %s.'],
   [c.ERROR_EVENTS_TRACKER, c.LOG_PREFIX_EVENTS_TRACKER + 'Failed to queue %s'],
@@ -28,8 +28,9 @@ export const codesError: [number, string][] = [
   [c.ERROR_INVALID, '%s: you passed an invalid %s. It must be a non-empty string.'],
   [c.ERROR_EMPTY, '%s: you passed an empty %s. It must be a non-empty string.'],
   [c.ERROR_EMPTY_ARRAY, '%s: %s must be a non-empty array.'],
+  [c.ERROR_NOT_BOOLEAN, '%s: provided param must be a boolean value.'],
   // initialization / settings validation
-  [c.ERROR_INVALID_IMPRESSIONS_MODE, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "impressionsMode". It should be one of the following values: %s. Defaulting to "%s" mode.'],
+  [c.ERROR_INVALID_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "%s" config param. It should be one of the following values: %s. Defaulting to "%s".'],
   [c.ERROR_LOCALHOST_MODULE_REQUIRED, c.LOG_PREFIX_SETTINGS + ': an invalid value was received for "sync.localhostMode" config. A valid entity should be provided for localhost mode.'],
   [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS+': The provided storage is invalid.%s Fallbacking into default MEMORY storage'],
 ];

package/src/logger/messages/info.ts

@@ -10,17 +10,19 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   // SDK
   [c.IMPRESSION, c.LOG_PREFIX_IMPRESSIONS_TRACKER +'Split: %s. Key: %s. Evaluation: %s. Label: %s'],
   [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER +'Queueing corresponding impression.'],
-  [c.NEW_SHARED_CLIENT, ' New shared client instance created.'],
-  [c.NEW_FACTORY, ' New Split SDK instance created.'],
+  [c.NEW_SHARED_CLIENT, 'New shared client instance created.'],
+  [c.NEW_FACTORY, 'New Split SDK instance created.'],
   [c.EVENTS_TRACKER_SUCCESS, c.LOG_PREFIX_EVENTS_TRACKER + 'Successfully queued %s'],
   [c.IMPRESSIONS_TRACKER_SUCCESS, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Successfully stored %s impression(s).'],
+  [c.USER_CONSENT_UPDATED, 'setUserConsent: consent status changed from %s to %s.'],
+  [c.USER_CONSENT_NOT_UPDATED, 'setUserConsent: call had no effect because it was the current consent status (%s).'],
 
   // synchronizer
   [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],
   [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
   [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
   [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of splits #%s. Reason: %s'],
-  [c.SUBMITTERS_PUSH_FULL_EVENTS_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full events queue and reseting timer.'],
+  [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
   [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s %s.'],
   [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
   [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],

package/src/sdkClient/client.ts

@@ -4,7 +4,7 @@ import { getMatching, getBucketing } from '../utils/key';
 import { validateSplitExistance } from '../utils/inputValidation/splitExistance';
 import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';
 import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL } from '../utils/constants';
+import { CONSENT_DECLINED, CONTROL } from '../utils/constants';
 import { IClientFactoryParams } from './types';
 import { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
@@ -16,13 +16,14 @@ import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
  */
 // @TODO missing time tracking to collect telemetry
 export function clientFactory(params: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager: { readinessManager }, storage, settings: { log, mode }, impressionsTracker, eventTracker } = params;
+  const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker } = params;
+  const { log, mode } = settings;
 
   function getTreatment(key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, withConfig = false) {
     const wrapUp = (evaluationResult: IEvaluationResult) => {
       const queue: ImpressionDTO[] = [];
       const treatment = processEvaluation(evaluationResult, splitName, key, attributes, withConfig, `getTreatment${withConfig ? 'withConfig' : ''}`, queue);
-      impressionsTracker.track(queue, attributes);
+      if (settings.userConsent !== CONSENT_DECLINED) impressionsTracker.track(queue, attributes);
       return treatment;
     };
 
@@ -42,7 +43,7 @@ export function clientFactory(params: IClientFactoryParams): SplitIO.IClient | S
       Object.keys(evaluationResults).forEach(splitName => {
         treatments[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, `getTreatments${withConfig ? 'withConfig' : ''}`, queue);
       });
-      impressionsTracker.track(queue, attributes);
+      if (settings.userConsent !== CONSENT_DECLINED) impressionsTracker.track(queue, attributes);
       return treatments;
     };
 
@@ -115,7 +116,8 @@ export function clientFactory(params: IClientFactoryParams): SplitIO.IClient | S
     // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
     validateTrafficTypeExistance(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
 
-    return eventTracker.track(eventData, size);
+    if (settings.userConsent !== CONSENT_DECLINED) return eventTracker.track(eventData, size);
+    else return false;
   }
 
   return {

package/src/sdkFactory/index.ts

@@ -12,13 +12,14 @@ 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';
 
 /**
  * Modular SDK factory
  */
 export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.ISDK | SplitIO.IAsyncSDK {
 
-  const { settings, platform, storageFactory, splitApiFactory,
+  const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory, impressionListener,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory } = params;
   const log = settings.log;
@@ -33,6 +34,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   // @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),
 
@@ -87,12 +89,12 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   log.info(NEW_FACTORY);
 
-  return {
+  // @ts-ignore
+  return objectAssign({
     // Split evaluation and event tracking engine
     client: clientMethod,
 
     // Manager API to explore available information
-    // @ts-ignore
     manager() {
       log.debug(RETRIEVE_MANAGER);
       return managerInstance;
@@ -102,5 +104,5 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     Logger: createLoggerAPI(settings.log),
 
     settings,
-  };
+  }, extraProps && extraProps(settings, syncManager));
 }

package/src/sdkFactory/types.ts

@@ -70,4 +70,6 @@ export interface ISdkFactoryParams {
   // Impression observer factory. If provided, will be used for impressions dedupe
   impressionsObserverFactory?: () => IImpressionObserver
 
+  // Optional function to assign additional properties to the factory instance
+  extraProps?: (settings: ISettings, syncManager?: ISyncManager) => object
 }

package/src/sdkFactory/userConsentProps.ts

@@ -0,0 +1,40 @@
+import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED, USER_CONSENT_NOT_UPDATED } from '../logger/constants';
+import { ISyncManager } from '../sync/types';
+import { ISettings } from '../types';
+import { CONSENT_GRANTED, CONSENT_DECLINED } from '../utils/constants';
+import { isBoolean } from '../utils/lang';
+
+// Extend client-side factory instances with user consent getter/setter
+export function userConsentProps(settings: ISettings, syncManager?: ISyncManager) {
+
+  const log = settings.log;
+
+  return {
+    setUserConsent(consent: unknown) {
+      // validate input param
+      if (!isBoolean(consent)) {
+        log.warn(ERROR_NOT_BOOLEAN, ['setUserConsent']);
+        return false;
+      }
+
+      const newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;
+
+      if (settings.userConsent !== newConsentStatus) { // @ts-ignore, modify readonly prop
+        settings.userConsent = newConsentStatus;
+
+        if (consent) syncManager?.submitter?.start(); // resumes submitters if transitioning to GRANTED
+        else syncManager?.submitter?.stop(); // pauses submitters if transitioning to DECLINED
+
+        log.info(USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]);
+      } else {
+        log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);
+      }
+
+      return true;
+    },
+
+    getUserConsent() {
+      return settings.userConsent;
+    }
+  };
+}

package/src/storages/KeyBuilder.ts

@@ -1,15 +1,11 @@
-import { endsWith, startsWith } from '../utils/lang';
+import { startsWith } from '../utils/lang';
 
 const everythingAtTheEnd = /[^.]+$/;
 
 const DEFAULT_PREFIX = 'SPLITIO';
 
 export function validatePrefix(prefix: unknown) {
-  return prefix && typeof prefix === 'string' ?
-    endsWith(prefix, '.' + DEFAULT_PREFIX) ?
-      prefix : // suffix already appended
-      prefix + '.' + DEFAULT_PREFIX : // append suffix
-    DEFAULT_PREFIX; // use default prefix if none is provided
+  return prefix ? prefix + '.SPLITIO' : 'SPLITIO';
 }
 
 export class KeyBuilder {

package/src/storages/KeyBuilderCS.ts

@@ -16,10 +16,22 @@ export class KeyBuilderCS extends KeyBuilder {
    * @override
    */
   buildSegmentNameKey(segmentName: string) {
-    return `${this.matchingKey}.${this.prefix}.segment.${segmentName}`;
+    return `${this.prefix}.${this.matchingKey}.segment.${segmentName}`;
   }
 
   extractSegmentName(builtSegmentKeyName: string) {
+    const prefix = `${this.prefix}.${this.matchingKey}.segment.`;
+
+    if (startsWith(builtSegmentKeyName, prefix))
+      return builtSegmentKeyName.substr(prefix.length);
+  }
+
+  // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
+  buildOldSegmentNameKey(segmentName: string) {
+    return `${this.matchingKey}.${this.prefix}.segment.${segmentName}`;
+  }
+  // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
+  extractOldSegmentKey(builtSegmentKeyName: string) {
     const prefix = `${this.matchingKey}.${this.prefix}.segment.`;
 
     if (startsWith(builtSegmentKeyName, prefix))

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -67,9 +67,29 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
 
     // Scan current values from localStorage
     const storedSegmentNames = Object.keys(localStorage).reduce((accum, key) => {
-      const name = this.keys.extractSegmentName(key);
-
-      if (name) accum.push(name);
+      let segmentName = this.keys.extractSegmentName(key);
+
+      if (segmentName) {
+        accum.push(segmentName);
+      } else {
+        // @BREAKING: This is only to clean up "old" keys. Remove this whole else code block.
+        segmentName = this.keys.extractOldSegmentKey(key);
+
+        if (segmentName) { // this was an old segment key, let's clean up.
+          const newSegmentKey = this.keys.buildSegmentNameKey(segmentName);
+          try {
+            // If the new format key is not there, create it.
+            if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
+              localStorage.setItem(newSegmentKey, DEFINED);
+              // we are migrating a segment, let's track it.
+              accum.push(segmentName);
+            }
+            localStorage.removeItem(key); // we migrated the current key, let's delete it.
+          } catch (e) {
+            this.log.error(e);
+          }
+        }
+      }
 
       return accum;
     }, [] as string[]);

package/src/storages/inLocalStorage/index.ts

@@ -40,7 +40,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
     return {
       splits: new SplitsCacheInLocal(log, keys, expirationTimestamp, params.splitFiltersValidation),
       segments: new MySegmentsCacheInLocal(log, keys),
-      impressions: new ImpressionsCacheInMemory(),
+      impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
       impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
       events: new EventsCacheInMemory(params.eventsQueueSize),
 

package/src/storages/inMemory/ImpressionsCacheInMemory.ts

@@ -3,13 +3,34 @@ import { ImpressionDTO } from '../../types';
 
 export class ImpressionsCacheInMemory implements IImpressionsCacheSync {
 
-  private queue: ImpressionDTO[] = [];
+  private onFullQueue?: () => void;
+  private readonly maxQueue: number;
+  private queue: ImpressionDTO[];
+
+  /**
+   *
+   * @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.
+   */
+  constructor(impressionsQueueSize: number = 0) {
+    this.maxQueue = impressionsQueueSize;
+    this.queue = [];
+  }
+
+  setOnFullQueueCb(cb: () => void) {
+    this.onFullQueue = cb;
+  }
 
   /**
    * Store impressions in sequential order
    */
   track(data: ImpressionDTO[]) {
     this.queue.push(...data);
+
+    // Check if the cache queue is full and we need to flush it.
+    if (this.maxQueue > 0 && this.queue.length >= this.maxQueue && this.onFullQueue) {
+      this.onFullQueue();
+    }
   }
 
   /**

package/src/storages/inMemory/InMemoryStorage.ts

@@ -16,7 +16,7 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
   return {
     splits: new SplitsCacheInMemory(),
     segments: new SegmentsCacheInMemory(),
-    impressions: new ImpressionsCacheInMemory(),
+    impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
     impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(params.eventsQueueSize),
 

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -16,7 +16,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
   return {
     splits: new SplitsCacheInMemory(),
     segments: new MySegmentsCacheInMemory(),
-    impressions: new ImpressionsCacheInMemory(),
+    impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
     impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(params.eventsQueueSize),
 

package/src/storages/pluggable/index.ts

@@ -63,7 +63,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
   const prefix = validatePrefix(options.prefix);
 
-  function PluggableStorageFactory({ log, metadata, onReadyCb, mode, eventsQueueSize, optimize }: IStorageFactoryParams): IStorageAsync {
+  function PluggableStorageFactory({ log, metadata, onReadyCb, mode, eventsQueueSize, impressionsQueueSize, optimize }: IStorageFactoryParams): IStorageAsync {
     const keys = new KeyBuilderSS(prefix, metadata);
     const wrapper = wrapperAdapter(log, options.wrapper);
     const isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
@@ -74,7 +74,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
     return {
       splits: new SplitsCachePluggable(log, keys, wrapper),
       segments: new SegmentsCachePluggable(log, keys, wrapper),
-      impressions: isPartialConsumer ? new ImpressionsCacheInMemory() : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
+      impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
       impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
       events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
       // @TODO add telemetry cache when required