@splitsoftware/splitio-commons 1.2.1-rc.1 → 1.2.1-rc.12

package/src/sync/submitters/eventsSyncTask.ts

@@ -3,7 +3,9 @@ import { IPostEventsBulk } from '../../services/types';
 import { ISyncTask, ITimeTracker } from '../types';
 import { submitterSyncTaskFactory } from './submitterSyncTask';
 import { ILogger } from '../../logger/types';
-import { SUBMITTERS_PUSH_FULL_EVENTS_QUEUE } from '../../logger/constants';
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+
+const DATA_NAME = 'events';
 
 /**
  * Sync task that periodically posts tracked events
@@ -18,26 +20,37 @@ export function eventsSyncTaskFactory(
 ): ISyncTask {
 
   // don't retry events.
-  const syncTask = submitterSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, 'queued events', latencyTracker);
+  const syncTask = submitterSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, DATA_NAME, latencyTracker);
 
-  // Set a timer for the first push of events,
+  // Set a timer for the first push window of events.
+  // Not implemented in the base submitter or sync task, since this feature is only used by the events submitter.
   if (eventsFirstPushWindow > 0) {
+    let running = false;
     let stopEventPublisherTimeout: ReturnType<typeof setTimeout>;
     const originalStart = syncTask.start;
     syncTask.start = () => {
+      running = true;
       stopEventPublisherTimeout = setTimeout(originalStart, eventsFirstPushWindow);
     };
     const originalStop = syncTask.stop;
     syncTask.stop = () => {
+      running = false;
       clearTimeout(stopEventPublisherTimeout);
       originalStop();
     };
+    syncTask.isRunning = () => {
+      return running;
+    };
   }
 
-  // register eventsSubmitter to be executed when events cache is full
+  // register events submitter to be executed when events cache is full
   eventsCache.setOnFullQueueCb(() => {
-    log.info(SUBMITTERS_PUSH_FULL_EVENTS_QUEUE);
-    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

@@ -6,6 +6,9 @@ import { ImpressionDTO } from '../../types';
 import { submitterSyncTaskFactory } from './submitterSyncTask';
 import { ImpressionsPayload } from './types';
 import { ILogger } from '../../logger/types';
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+
+const DATA_NAME = 'impressions';
 
 /**
  * Converts `impressions` data from cache into request payload.
@@ -50,5 +53,17 @@ export function impressionsSyncTaskFactory(
 ): ISyncTask {
 
   // retry impressions only once.
-  return submitterSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, 'impressions', latencyTracker, fromImpressionsCollector.bind(undefined, sendLabels), 1);
+  const 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(() => {
+    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/syncManagerOnline.ts

@@ -6,6 +6,7 @@ import { IPushManager } from './streaming/types';
 import { IPollingManager, IPollingManagerCS } from './polling/types';
 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 '../consent';
 
 /**
  * Online SyncManager factory.
@@ -25,7 +26,7 @@ export function syncManagerOnlineFactory(
    */
   return function (params: ISyncManagerFactoryParams): ISyncManagerCS {
 
-    const { log, streamingEnabled } = params.settings;
+    const { settings, settings: { log, streamingEnabled } } = params;
 
     /** Polling Manager */
     const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
@@ -39,7 +40,6 @@ export function syncManagerOnlineFactory(
     // It is not inyected as push and polling managers, because at the moment it is required
     const submitter = submitterManagerFactory(params);
 
-
     /** Sync Manager logic */
 
     function startPolling() {
@@ -69,12 +69,18 @@ export function syncManagerOnlineFactory(
     let 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,
       pushManager,
+      submitter,
 
       /**
        * Method used to start the syncManager for the first time, or resume it after being stopped.
        */
       start() {
+        running = true;
+
         // start syncing splits and segments
         if (pollingManager) {
           if (pushManager) {
@@ -90,21 +96,21 @@ export function syncManagerOnlineFactory(
         }
 
         // start periodic data recording (events, impressions, telemetry).
-        if (submitter) submitter.start();
-        running = true;
+        if (isConsentGranted(settings)) submitter.start();
       },
 
       /**
        * Method used to stop/pause the syncManager.
        */
       stop() {
+        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() {
@@ -112,7 +118,7 @@ export function syncManagerOnlineFactory(
       },
 
       flush() {
-        if (submitter) return submitter.execute();
+        if (isConsentGranted(settings)) return submitter.execute();
         else return Promise.resolve();
       },
 

package/src/sync/types.ts

@@ -3,6 +3,7 @@ import { IPlatform } from '../sdkFactory/types';
 import { ISplitApi } from '../services/types';
 import { IStorageSync } from '../storages/types';
 import { ISettings } from '../types';
+import { IPollingManager } from './polling/types';
 import { IPushManager } from './streaming/types';
 
 export interface ITask<Input extends any[] = []> {
@@ -43,7 +44,9 @@ export interface ITimeTracker {
 
 export interface ISyncManager extends ITask {
   flush(): Promise<any>,
-  pushManager?: IPushManager
+  pushManager?: IPushManager,
+  pollingManager?: IPollingManager,
+  submitter?: ISyncTask
 }
 
 export interface ISyncManagerCS extends ISyncManager {

package/src/trackers/eventTracker.ts

@@ -2,9 +2,10 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { IEventsCacheBase } from '../storages/types';
 import { IEventsHandler, IEventTracker } from './types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
+import { ISettings, SplitIO } from '../types';
 import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
+import { CONSENT_DECLINED } from '../utils/constants';
+import { isStorageSync } from './impressionObserver/utils';
 
 /**
  * Event tracker stores events in cache and pass them to the integrations manager if provided.
@@ -13,11 +14,14 @@ import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constant
  * @param integrationsManager optional event handler used for integrations
  */
 export function eventTrackerFactory(
-  log: ILogger,
+  settings: ISettings,
   eventsCache: IEventsCacheBase,
   integrationsManager?: IEventsHandler
 ): IEventTracker {
 
+  const log = settings.log;
+  const isSync = isStorageSync(settings);
+
   function queueEventsCallback(eventData: SplitIO.EventData, tracked: boolean) {
     const { eventTypeId, trafficTypeName, key, value, timestamp, properties } = eventData;
     // Logging every prop would be too much.
@@ -44,6 +48,10 @@ export function eventTrackerFactory(
 
   return {
     track(eventData: SplitIO.EventData, size?: number) {
+      if (settings.userConsent === CONSENT_DECLINED) {
+        return isSync ? false : Promise.resolve(false);
+      }
+
       const tracked = eventsCache.track(eventData, size);
 
       if (thenable(tracked)) {

package/src/trackers/impressionObserver/utils.ts

@@ -1,4 +1,4 @@
-import { CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
+import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
 import { ISettings } from '../../types';
 
 /**
@@ -15,3 +15,10 @@ export function shouldBeOptimized(settings: ISettings) {
   if (!shouldAddPt(settings)) return false;
   return settings.sync.impressionsMode === OPTIMIZED ? true : false;
 }
+
+/**
+ * Storage is async if mode is consumer or partial consumer
+ */
+export function isStorageSync(settings: ISettings) {
+  return [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false;
+}

package/src/trackers/impressionsTracker.ts

@@ -5,8 +5,8 @@ import { IImpressionCountsCacheSync, IImpressionsCacheBase } from '../storages/t
 import { IImpressionsHandler, IImpressionsTracker } from './types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
 import { IImpressionObserver } from './impressionObserver/types';
-import { ILogger } from '../logger/types';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
+import { CONSENT_DECLINED } from '../utils/constants';
 
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
@@ -19,22 +19,21 @@ import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIO
  * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
  */
 export function impressionsTrackerFactory(
-  log: ILogger,
+  settings: ISettings,
   impressionsCache: IImpressionsCacheBase,
-
-  // @TODO consider passing only an optional integrationsManager to handle impressions
-  { runtime: { ip, hostname }, version }: Pick<ISettings, 'version' | 'runtime'>,
-  impressionListener?: SplitIO.IImpressionListener,
   integrationsManager?: IImpressionsHandler,
-
   // if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
   observer?: IImpressionObserver,
   // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
   countsCache?: IImpressionCountsCacheSync
 ): IImpressionsTracker {
 
+  const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
+
   return {
     track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes) {
+      if (settings.userConsent === CONSENT_DECLINED) return;
+
       const impressionsCount = impressions.length;
 
       const impressionsToStore: ImpressionDTO[] = []; // Track only the impressions that are going to be stored
@@ -85,7 +84,7 @@ export function impressionsTrackerFactory(
             // integrationsManager.handleImpression does not throw errors
             if (integrationsManager) integrationsManager.handleImpression(impressionData);
 
-            try { // An exception on the listeners should not break the SDK.
+            try { // @ts-ignore. An exception on the listeners should not break the SDK.
               if (impressionListener) impressionListener.logImpression(impressionData);
             } catch (err) {
               log.error(ERROR_IMPRESSIONS_LISTENER, [err]);

package/src/types.ts

@@ -54,6 +54,11 @@ type EventConsts = {
  * @typedef {string} SDKMode
  */
 export type SDKMode = 'standalone' | 'consumer' | 'localhost' | 'consumer_partial';
+/**
+ * User consent status.
+ * @typedef {string} ConsentStatus
+ */
+export type ConsentStatus = 'GRANTED' | 'DECLINED' | 'UNKNOWN';
 /**
  * Settings interface. This is a representation of the settings the SDK expose, that's why
  * most of it's props are readonly. Only features should be rewritten when localhost mode is active.
@@ -73,6 +78,7 @@ export interface ISettings {
   readonly scheduler: {
     featuresRefreshRate: number,
     impressionsRefreshRate: number,
+    impressionsQueueSize: number,
     metricsRefreshRate: number,
     segmentsRefreshRate: number,
     offlineRefreshRate: number,
@@ -110,6 +116,7 @@ export interface ISettings {
   },
   readonly log: ILogger
   readonly impressionListener?: unknown
+  readonly userConsent?: ConsentStatus
 }
 /**
  * Log levels.
@@ -255,6 +262,13 @@ interface INodeBasicSettings extends ISharedSettings {
      * @default 300
      */
     impressionsRefreshRate?: number,
+    /**
+     * The maximum number of impression items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
+     * If you use a 0 here, the queue will have no maximum size.
+     * @property {number} impressionsQueueSize
+     * @default 30000
+     */
+    impressionsQueueSize?: number,
     /**
      * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
      * @property {number} metricsRefreshRate
@@ -384,7 +398,7 @@ interface IBasicClient extends IStatusInterface {
 
   // Whether the client implements the client-side API, i.e, with bound key, (true), or the server-side API (false).
   // Exposed for internal purposes only. Not considered part of the public API, and might be renamed eventually.
-  isBrowserClient: boolean
+  isClientSide: boolean
 }
 /**
  * Common definitions between SDK instances for different environments interface.
@@ -769,6 +783,13 @@ export namespace SplitIO {
        * @default 60
        */
       impressionsRefreshRate?: number,
+      /**
+       * The maximum number of impression items we want to queue. If we queue more values, it will trigger a flush and reset the timer.
+       * If you use a 0 here, the queue will have no maximum size.
+       * @property {number} impressionsQueueSize
+       * @default 30000
+       */
+      impressionsQueueSize?: number,
       /**
        * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
        * @property {number} metricsRefreshRate

package/src/utils/constants/index.ts

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

package/src/utils/inputValidation/attributes.ts

@@ -6,7 +6,7 @@ import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 
 export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false {
   // Attributes are optional
-  if (isObject(maybeAttrs) || maybeAttrs == undefined) // eslint-disable-line eqeqeq
+  if (maybeAttrs == undefined || isObject(maybeAttrs)) // eslint-disable-line eqeqeq
     return maybeAttrs;
 
   log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
@@ -23,5 +23,4 @@ export function validateAttributesDeep(log: ILogger, maybeAttributes: Record<str
   });
 
   return result;
-
 }

package/src/utils/lang/index.ts

@@ -89,7 +89,7 @@ export function get(obj: any, prop: any, val: any): any {
 /**
  * Parses an array into a map of different arrays, grouping by the specified prop value.
  */
-export function groupBy<T extends Record<string, any> >(source: T[], prop: string): Record<string, T[]> {
+export function groupBy<T extends Record<string, any>>(source: T[], prop: string): Record<string, T[]> {
   const map: Record<string, any[]> = {};
 
   if (Array.isArray(source) && isString(prop)) {
@@ -151,10 +151,14 @@ export function isNaNNumber(val: any): boolean {
 }
 
 /**
- * Validates if a value is an object with the Object prototype (map object).
+ * Validates if a value is an object created by the Object constructor (plain object).
+ * It checks `constructor.name` to avoid false negatives when validating values on a separate VM context, which has its own global built-ins.
  */
-export function isObject(obj: any): boolean {
-  return obj !== null && typeof obj === 'object' && obj.constructor === Object;
+export function isObject(obj: any) {
+  return obj !== null && typeof obj === 'object' && (
+    obj.constructor === Object ||
+    (obj.constructor != null && obj.constructor.name === 'Object')
+  );
 }
 
 /**
@@ -164,6 +168,13 @@ export function isString(val: any): val is string {
   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: any) {
+  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/src/utils/lang/maps.ts

@@ -79,4 +79,18 @@ interface IMapConstructor {
   readonly prototype: IMap<any, any>;
 }
 
-export const _Map: IMapConstructor = typeof Map !== 'undefined' ? Map : MapPoly;
+/**
+ * return the Map constructor to use. If native Map is not available or it doesn't support the required features (e.g., IE11),
+ * a ponyfill with minimal features is returned instead.
+ *
+ * Exported for testing purposes only.
+ */
+export function __getMapConstructor(): IMapConstructor {
+  // eslint-disable-next-line compat/compat
+  if (typeof Array.from === 'function' && typeof Map === 'function' && Map.prototype && Map.prototype.values) {
+    return Map;
+  }
+  return MapPoly;
+}
+
+export const _Map = __getMapConstructor();

package/src/utils/settingsValidation/consent.ts

@@ -0,0 +1,16 @@
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
+import { ConsentStatus } from '../../types';
+import { CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN } from '../constants';
+import { stringToUpperCase } from '../lang';
+
+const userConsentValues = [CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN];
+
+export function validateConsent({ userConsent, log }: { userConsent?: any, log: ILogger }): ConsentStatus {
+  userConsent = stringToUpperCase(userConsent);
+
+  if (userConsentValues.indexOf(userConsent) > -1) return userConsent;
+
+  log.error(ERROR_INVALID_CONFIG_PARAM, ['userConsent', userConsentValues, CONSENT_GRANTED]);
+  return CONSENT_GRANTED;
+}

package/src/utils/settingsValidation/impressionsMode.ts

@@ -1,14 +1,14 @@
-import { ERROR_INVALID_IMPRESSIONS_MODE } from '../../logger/constants';
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 import { SplitIO } from '../../types';
 import { DEBUG, OPTIMIZED } from '../constants';
+import { stringToUpperCase } from '../lang';
 
-export function validImpressionsMode(log: ILogger, impressionsMode: string): SplitIO.ImpressionsMode {
-  impressionsMode = impressionsMode.toUpperCase();
-  if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) === -1) {
-    log.error(ERROR_INVALID_IMPRESSIONS_MODE, [[DEBUG, OPTIMIZED], OPTIMIZED]);
-    impressionsMode = OPTIMIZED;
-  }
+export function validImpressionsMode(log: ILogger, impressionsMode: any): SplitIO.ImpressionsMode {
+  impressionsMode = stringToUpperCase(impressionsMode);
 
-  return impressionsMode as SplitIO.ImpressionsMode;
+  if ([DEBUG, OPTIMIZED].indexOf(impressionsMode) > -1) return impressionsMode;
+
+  log.error(ERROR_INVALID_CONFIG_PARAM, ['impressionsMode', [DEBUG, OPTIMIZED], OPTIMIZED]);
+  return OPTIMIZED;
 }

package/src/utils/settingsValidation/index.ts

@@ -5,6 +5,8 @@ import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
 import { ISettingsValidationParams } from './types';
 import { ISettings } from '../../types';
+import { validateKey } from '../inputValidation/key';
+import { validateTrafficType } from '../inputValidation/trafficType';
 
 const base = {
   // Define which kind of object you want to retrieve from SplitFactory
@@ -38,6 +40,8 @@ const 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,11 +82,6 @@ const base = {
     localhostMode: undefined
   },
 
-  runtime: {
-    ip: false,
-    hostname: false
-  },
-
   // Logger
   log: undefined
 };
@@ -100,7 +99,7 @@ function fromSecondsToMillis(n: number) {
  */
 export function settingsValidation(config: unknown, validationParams: ISettingsValidationParams) {
 
-  const { defaults, runtime, storage, integrations, logger, localhost } = validationParams;
+  const { defaults, runtime, storage, integrations, logger, localhost, consent } = validationParams;
 
   // creates a settings object merging base, defaults and config objects.
   const withDefaults = merge({}, base, defaults, config) as ISettings;
@@ -132,14 +131,30 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // @ts-ignore, modify readonly prop
   if (storage) withDefaults.storage = storage(withDefaults);
 
-  // Although `key` is mandatory according to TS declaration files, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
-  if (withDefaults.mode === LOCALHOST_MODE && withDefaults.core.key === undefined) {
-    withDefaults.core.key = 'localhost_key';
+  // Validate key and TT (for client-side)
+  if (validationParams.acceptKey) {
+    const 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';
+    } else {
+      // Keeping same behaviour than JS SDK: if settings key or TT are invalid,
+      // `false` value is used as binded key/TT of the default client, which leads to some issues.
+      // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
+      withDefaults.core.key = validateKey(log, maybeKey, 'Client instantiation');
+    }
+
+    if (validationParams.acceptTT) {
+      const maybeTT = withDefaults.core.trafficType;
+      if (maybeTT !== undefined) { // @ts-ignore
+        withDefaults.core.trafficType = validateTrafficType(log, maybeTT, 'Client instantiation');
+      }
+    }
   }
 
   // Current ip/hostname information
   // @ts-ignore, modify readonly prop
-  if (runtime) withDefaults.runtime = runtime(withDefaults);
+  withDefaults.runtime = runtime(withDefaults);
 
   // ensure a valid list of integrations.
   // `integrations` returns an array of valid integration items.
@@ -164,5 +179,9 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // 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/src/utils/settingsValidation/runtime.ts

@@ -0,0 +1,9 @@
+import { ISettings } from '../../types';
+
+// For client-side SDKs, machine IP and Hostname are not captured and sent to Split backend.
+export function validateRuntime(): ISettings['runtime'] {
+  return {
+    ip: false,
+    hostname: false
+  };
+}

package/src/utils/settingsValidation/types.ts

@@ -6,18 +6,24 @@ import { ISettings } from '../../types';
  */
 export interface ISettingsValidationParams {
   /**
-   * Object of values to overwrite default settings.
-   * Version and startup properties are mandatory, because these values are not part of the base setting.
+   * Object of values to overwrite base settings.
+   * Version and startup properties are required, because they are not defined in the base settings.
    */
   defaults: Partial<ISettings> & { version: string } & { startup: ISettings['startup'] },
-  /** Function to overwrite runtime values (ip and hostname) which are false by default */
-  runtime?: (settings: ISettings) => ISettings['runtime'],
-  /** Storage validator */
+  /** If true, validates core.key */
+  acceptKey?: boolean,
+  /** If true, validates core.trafficType */
+  acceptTT?: boolean,
+  /** Define runtime values (`settings.runtime`) */
+  runtime: (settings: ISettings) => ISettings['runtime'],
+  /** Storage validator (`settings.storage`) */
   storage?: (settings: ISettings) => ISettings['storage'],
-  /** Integrations validator */
+  /** Integrations validator (`settings.integrations`) */
   integrations?: (settings: ISettings) => ISettings['integrations'],
   /** Logger validator (`settings.debug`) */
   logger: (settings: ISettings) => ISettings['log'],
   /** Localhost mode validator (`settings.sync.localhostMode`) */
   localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'],
+  /** User consent validator (`settings.userConsent`) */
+  consent: (settings: ISettings) => ISettings['userConsent'],
 }

package/types/consent/index.d.ts

@@ -0,0 +1,2 @@
+import { ISettings } from '../types';
+export declare function isConsentGranted(settings: ISettings): boolean;

package/types/consent/sdkUserConsent.d.ts

@@ -0,0 +1,13 @@
+import { ISdkFactoryContext } from '../sdkFactory/types';
+/**
+ * The public user consent API exposed via SplitFactory, used to control if the SDK tracks and sends impressions and events or not.
+ */
+export declare function createUserConsentAPI(params: ISdkFactoryContext): {
+    setStatus(consent: unknown): boolean;
+    getStatus(): import("../types").ConsentStatus | undefined;
+    Status: {
+        GRANTED: string;
+        DECLINED: string;
+        UNKNOWN: string;
+    };
+};

package/types/evaluator/types.d.ts

@@ -5,7 +5,7 @@ import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
 export interface IDependencyMatcherValue {
     key: SplitIO.SplitKey;
-    attributes: SplitIO.Attributes;
+    attributes?: SplitIO.Attributes;
 }
 export interface IMatcherDto {
     type: number;
@@ -23,6 +23,6 @@ export interface IEvaluation {
 export declare type IEvaluationResult = IEvaluation & {
     treatment: string;
 };
-export declare type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>;
+export declare type ISplitEvaluator = (log: ILogger, key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, storage: IStorageSync | IStorageAsync) => MaybeThenable<IEvaluation>;
 export declare type IEvaluator = (key: SplitIO.SplitKey, seed: number, trafficAllocation?: number, trafficAllocationSeed?: number, attributes?: SplitIO.Attributes, splitEvaluator?: ISplitEvaluator) => MaybeThenable<IEvaluation | undefined>;
 export declare type IMatcher = (...args: any) => MaybeThenable<boolean>;

package/types/evaluator/value/index.d.ts

@@ -4,4 +4,4 @@ import { ILogger } from '../../logger/types';
 /**
  * Defines value to be matched (key / attribute).
  */
-export declare function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;
+export declare function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes): string | number | boolean | (string | number)[] | import("../types").IDependencyMatcherValue | undefined;

package/types/evaluator/value/sanitize.d.ts

@@ -4,4 +4,4 @@ import { ILogger } from '../../logger/types';
 /**
  * Sanitize matcher value
  */
-export declare function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;
+export declare function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: SplitIO.Attributes): string | number | boolean | (string | number)[] | IDependencyMatcherValue | undefined;