@splitsoftware/splitio-commons 1.2.1-rc.4 → 1.2.1-rc.5

package/esm/sdkFactory/index.js

@@ -8,11 +8,12 @@ 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) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, impressionListener = params.impressionListener, 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, impressionListener = params.impressionListener, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory;
     var log = settings.log;
     // @TODO handle non-recoverable errors: not start sync, mark the SDK as destroyed, etc.
     // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
@@ -65,11 +66,11 @@ export function sdkFactory(params) {
     syncManager && syncManager.start();
     signalListener && signalListener.start();
     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: function () {
             log.debug(RETRIEVE_MANAGER);
             return managerInstance;
@@ -77,5 +78,5 @@ export function sdkFactory(params) {
         // Logger wrapper API
         Logger: createLoggerAPI(settings.log),
         settings: settings,
-    };
+    }, extraProps && extraProps(settings, syncManager));
 }

package/esm/sdkFactory/userConsentProps.js

@@ -0,0 +1,30 @@
+import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED } from '../logger/constants';
+import { CONSENT_GRANTED, CONSENT_DECLINED } from '../utils/constants';
+// Extend client-side factory instances with user consent getter/setter
+export function userConsentProps(settings, syncManager) {
+    var log = settings.log;
+    return {
+        setUserConsent: function (consent) {
+            var _a, _b;
+            // validate input param
+            if (typeof consent !== 'boolean') {
+                log.error(ERROR_NOT_BOOLEAN, ['setUserConsent']);
+                return false;
+            }
+            var newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;
+            if (settings.userConsent !== newConsentStatus) {
+                // resume/pause submitters
+                if (consent)
+                    (_a = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _a === void 0 ? void 0 : _a.start();
+                else
+                    (_b = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _b === void 0 ? void 0 : _b.stop();
+                log.info(USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]); // @ts-ignore, modify readonly prop
+                settings.userConsent = newConsentStatus;
+            }
+            return true;
+        },
+        getUserConsent: function () {
+            return settings.userConsent;
+        }
+    };
+}

package/esm/storages/KeyBuilderCS.js

@@ -13,9 +13,19 @@ var KeyBuilderCS = /** @class */ (function (_super) {
      * @override
      */
     KeyBuilderCS.prototype.buildSegmentNameKey = function (segmentName) {
-        return this.matchingKey + "." + this.prefix + ".segment." + segmentName;
+        return this.prefix + "." + this.matchingKey + ".segment." + segmentName;
     };
     KeyBuilderCS.prototype.extractSegmentName = function (builtSegmentKeyName) {
+        var 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
+    KeyBuilderCS.prototype.buildOldSegmentNameKey = function (segmentName) {
+        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
+    KeyBuilderCS.prototype.extractOldSegmentKey = function (builtSegmentKeyName) {
         var prefix = this.matchingKey + "." + this.prefix + ".segment.";
         if (startsWith(builtSegmentKeyName, prefix))
             return builtSegmentKeyName.substr(prefix.length);

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -57,9 +57,29 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         var index;
         // Scan current values from localStorage
         var storedSegmentNames = Object.keys(localStorage).reduce(function (accum, key) {
-            var name = _this.keys.extractSegmentName(key);
-            if (name)
-                accum.push(name);
+            var 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.
+                    var 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;
         }, []);
         // Extreme fast => everything is empty

package/esm/sync/submitters/eventsSyncTask.js

@@ -22,8 +22,12 @@ export function eventsSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPu
     }
     // register events submitter to be executed when events cache is full
     eventsCache.setOnFullQueueCb(function () {
-        log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
-        syncTask.execute();
+        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/sync/submitters/impressionsSyncTask.js

@@ -37,8 +37,12 @@ export function impressionsSyncTaskFactory(log, postTestImpressionsBulk, impress
     var syncTask = submitterSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, DATA_NAME, latencyTracker, fromImpressionsCollector.bind(undefined, sendLabels), 1);
     // register impressions submitter to be executed when impressions cache is full
     impressionsCache.setOnFullQueueCb(function () {
-        log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
-        syncTask.execute();
+        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/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/settingsValidation/consent.js

@@ -0,0 +1,12 @@
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
+import { CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN } from '../constants';
+var userConsentValues = [CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN];
+export function validateConsent(_a) {
+    var userConsent = _a.userConsent, log = _a.log;
+    if (typeof userConsent === 'string')
+        userConsent = userConsent.toUpperCase();
+    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';
 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;
+    if (typeof impressionsMode === 'string')
+        impressionsMode = impressionsMode.toUpperCase();
+    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

@@ -80,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.
@@ -133,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.2.1-rc.4",
+  "version": "1.2.1-rc.5",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

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

@@ -68,6 +68,7 @@ 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 ENGINE_VALUE_INVALID = 200;
 export const ENGINE_VALUE_NO_ATTRIBUTES = 201;
@@ -115,10 +116,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/error.ts

@@ -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: you must provide a boolean param.'],
   // 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

@@ -14,6 +14,7 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [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, 'User consent changed from %s to %s.'],
 
   // synchronizer
   [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],

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;
@@ -88,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;
@@ -103,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,37 @@
+import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED } from '../logger/constants';
+import { ISyncManager } from '../sync/types';
+import { ISettings } from '../types';
+import { CONSENT_GRANTED, CONSENT_DECLINED } from '../utils/constants';
+
+// 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 (typeof consent !== 'boolean') {
+        log.error(ERROR_NOT_BOOLEAN, ['setUserConsent']);
+        return false;
+      }
+
+      const newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;
+
+      if (settings.userConsent !== newConsentStatus) {
+        // resume/pause submitters
+        if (consent) syncManager?.submitter?.start();
+        else syncManager?.submitter?.stop();
+
+        log.info(USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]); // @ts-ignore, modify readonly prop
+        settings.userConsent = newConsentStatus;
+      }
+
+      return true;
+    },
+
+    getUserConsent() {
+      return settings.userConsent;
+    }
+  };
+}

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/sync/submitters/eventsSyncTask.ts

@@ -38,8 +38,12 @@ export function eventsSyncTaskFactory(
 
   // register events submitter to be executed when events cache is full
   eventsCache.setOnFullQueueCb(() => {
-    log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
-    syncTask.execute();
+    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/src/sync/submitters/impressionsSyncTask.ts

@@ -57,8 +57,12 @@ export function impressionsSyncTaskFactory(
 
   // register impressions submitter to be executed when impressions cache is full
   impressionsCache.setOnFullQueueCb(() => {
-    log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
-    syncTask.execute();
+    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;