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

package/esm/sdkFactory/userConsentProps.js

@@ -1,5 +1,6 @@
-import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED } from '../logger/constants';
+import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED, USER_CONSENT_NOT_UPDATED } from '../logger/constants';
 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, syncManager) {
     var log = settings.log;
@@ -7,19 +8,21 @@ export function userConsentProps(settings, syncManager) {
         setUserConsent: function (consent) {
             var _a, _b;
             // validate input param
-            if (typeof consent !== 'boolean') {
-                log.error(ERROR_NOT_BOOLEAN, ['setUserConsent']);
+            if (!isBoolean(consent)) {
+                log.warn(ERROR_NOT_BOOLEAN, ['setUserConsent']);
                 return false;
             }
             var newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;
-            if (settings.userConsent !== newConsentStatus) {
-                // resume/pause submitters
+            if (settings.userConsent !== newConsentStatus) { // @ts-ignore, modify readonly prop
+                settings.userConsent = newConsentStatus;
                 if (consent)
-                    (_a = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _a === void 0 ? void 0 : _a.start();
+                    (_a = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _a === void 0 ? void 0 : _a.start(); // resumes submitters if transitioning to GRANTED
                 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;
+                    (_b = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _b === void 0 ? void 0 : _b.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;
         },

package/esm/storages/KeyBuilder.js

@@ -1,12 +1,8 @@
-import { endsWith, startsWith } from '../utils/lang';
+import { startsWith } from '../utils/lang';
 var everythingAtTheEnd = /[^.]+$/;
 var DEFAULT_PREFIX = 'SPLITIO';
 export function validatePrefix(prefix) {
-    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';
 }
 var KeyBuilder = /** @class */ (function () {
     function KeyBuilder(prefix) {

package/esm/sync/streaming/SSEClient/index.js

@@ -1,3 +1,4 @@
+import { isString } from '../../../utils/lang';
 var VERSION = '1.1';
 var CONTROL_CHANNEL_REGEX = /^control_/;
 /**
@@ -8,7 +9,7 @@ var CONTROL_CHANNEL_REGEX = /^control_/;
  */
 function buildSSEHeaders(settings) {
     var headers = {
-        SplitSDKClientKey: settings.core.authorizationKey.slice(-4),
+        SplitSDKClientKey: isString(settings.core.authorizationKey) ? settings.core.authorizationKey.slice(-4) : '',
         SplitSDKVersion: settings.version,
     };
     // ip and hostname are false if IPAddressesEnabled is false

package/esm/sync/submitters/eventsSyncTask.js

@@ -7,18 +7,25 @@ var DATA_NAME = 'events';
 export function eventsSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, eventsFirstPushWindow, latencyTracker) {
     // don't retry events.
     var 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) {
+        var running_1 = false;
         var stopEventPublisherTimeout_1;
         var originalStart_1 = syncTask.start;
         syncTask.start = function () {
+            running_1 = true;
             stopEventPublisherTimeout_1 = setTimeout(originalStart_1, eventsFirstPushWindow);
         };
         var originalStop_1 = syncTask.stop;
         syncTask.stop = function () {
+            running_1 = false;
             clearTimeout(stopEventPublisherTimeout_1);
             originalStop_1();
         };
+        syncTask.isRunning = function () {
+            return running_1;
+        };
     }
     // register events submitter to be executed when events cache is full
     eventsCache.setOnFullQueueCb(function () {

package/esm/trackers/eventTracker.js

@@ -1,13 +1,17 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 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.
  *
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export function eventTrackerFactory(log, eventsCache, integrationsManager) {
+export function eventTrackerFactory(settings, eventsCache, integrationsManager) {
+    var log = settings.log;
+    var isSync = isStorageSync(settings);
     function queueEventsCallback(eventData, tracked) {
         var eventTypeId = eventData.eventTypeId, trafficTypeName = eventData.trafficTypeName, key = eventData.key, value = eventData.value, timestamp = eventData.timestamp, properties = eventData.properties;
         // Logging every prop would be too much.
@@ -33,6 +37,9 @@ export function eventTrackerFactory(log, eventsCache, integrationsManager) {
     }
     return {
         track: function (eventData, size) {
+            if (settings.userConsent === CONSENT_DECLINED) {
+                return isSync ? false : Promise.resolve(false);
+            }
             var tracked = eventsCache.track(eventData, size);
             if (thenable(tracked)) {
                 return tracked.then(queueEventsCallback.bind(null, eventData));

package/esm/trackers/impressionObserver/utils.js

@@ -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';
 /**
  * Checks if impressions previous time should be added or not.
  */
@@ -13,3 +13,9 @@ export function shouldBeOptimized(settings) {
         return false;
     return settings.sync.impressionsMode === OPTIMIZED ? true : false;
 }
+/**
+ * Storage is async if mode is consumer or partial consumer
+ */
+export function isStorageSync(settings) {
+    return [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false;
+}

package/esm/trackers/impressionsTracker.js

@@ -2,6 +2,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { truncateTimeFrame } from '../utils/time';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
+import { CONSENT_DECLINED } from '../utils/constants';
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  *
@@ -12,16 +13,16 @@ import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIO
  * @param observer optional impression observer. If provided, previous time (pt property) is included in impression instances
  * @param countsCache optional cache to save impressions count. If provided, impressions will be deduped (OPTIMIZED mode)
  */
-export function impressionsTrackerFactory(log, impressionsCache, 
-// @TODO consider passing only an optional integrationsManager to handle impressions
-_a, impressionListener, integrationsManager, 
+export function impressionsTrackerFactory(settings, impressionsCache, integrationsManager, 
 // if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
 observer, 
 // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
 countsCache) {
-    var _b = _a.runtime, ip = _b.ip, hostname = _b.hostname, version = _a.version;
+    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
+            if (settings.userConsent === CONSENT_DECLINED)
+                return;
             var impressionsCount = impressions.length;
             var impressionsToStore = []; // Track only the impressions that are going to be stored
             // Wraps impressions to store and adds previousTime if it corresponds
@@ -65,7 +66,7 @@ countsCache) {
                         // 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);
                         }

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

@@ -1,10 +1,10 @@
 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;
-    if (typeof userConsent === 'string')
-        userConsent = userConsent.toUpperCase();
+    userConsent = stringToUpperCase(userConsent);
     if (userConsentValues.indexOf(userConsent) > -1)
         return userConsent;
     log.error(ERROR_INVALID_CONFIG_PARAM, ['userConsent', userConsentValues, CONSENT_GRANTED]);

package/esm/utils/settingsValidation/impressionsMode.js

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

package/package.json

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

package/src/logger/constants.ts

@@ -69,6 +69,7 @@ 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;

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,7 +28,7 @@ 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.'],
+  [c.ERROR_NOT_BOOLEAN, '%s: provided param must be a boolean value.'],
   // initialization / settings validation
   [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.'],

package/src/logger/messages/info.ts

@@ -10,11 +10,12 @@ 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, 'User consent changed from %s to %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.'],

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 { CONSENT_DECLINED, CONTROL } from '../utils/constants';
+import { CONTROL } from '../utils/constants';
 import { IClientFactoryParams } from './types';
 import { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
@@ -23,7 +23,7 @@ export function clientFactory(params: IClientFactoryParams): SplitIO.IClient | S
     const wrapUp = (evaluationResult: IEvaluationResult) => {
       const queue: ImpressionDTO[] = [];
       const treatment = processEvaluation(evaluationResult, splitName, key, attributes, withConfig, `getTreatment${withConfig ? 'withConfig' : ''}`, queue);
-      if (settings.userConsent !== CONSENT_DECLINED) impressionsTracker.track(queue, attributes);
+      impressionsTracker.track(queue, attributes);
       return treatment;
     };
 
@@ -43,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);
       });
-      if (settings.userConsent !== CONSENT_DECLINED) impressionsTracker.track(queue, attributes);
+      impressionsTracker.track(queue, attributes);
       return treatments;
     };
 
@@ -116,8 +116,7 @@ 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');
 
-    if (settings.userConsent !== CONSENT_DECLINED) return eventTracker.track(eventData, size);
-    else return false;
+    return eventTracker.track(eventData, size);
   }
 
   return {

package/src/sdkClient/clientInputValidation.ts

@@ -15,14 +15,17 @@ import { startsWith } from '../utils/lang';
 import { CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
 import { IReadinessManager } from '../readiness/types';
 import { MaybeThenable } from '../dtos/types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
+import { ISettings, SplitIO } from '../types';
+import { isStorageSync } from '../trackers/impressionObserver/utils';
 
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient, readinessManager: IReadinessManager, isStorageSync = false): TClient {
+export function clientInputValidationDecorator<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(settings: ISettings, client: TClient, readinessManager: IReadinessManager): TClient {
+
+  const log = settings.log;
+  const isSync = isStorageSync(settings);
 
   /**
    * Avoid repeating this validations code
@@ -47,8 +50,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   }
 
   function wrapResult<T>(value: T): MaybeThenable<T> {
-    if (isStorageSync) return value;
-    return Promise.resolve(value);
+    return isSync ? value : Promise.resolve(value);
   }
 
   function getTreatment(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
@@ -108,8 +110,7 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     if (isOperational && key && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error
       return client.track(key, tt, event, eventValue, properties, size);
     } else {
-      if (isStorageSync) return false;
-      return Promise.resolve(false);
+      return isSync ? false : Promise.resolve(false);
     }
   }
 

package/src/sdkClient/sdkClient.ts

@@ -1,6 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { IStatusInterface, SplitIO } from '../types';
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../utils/constants';
 import { releaseApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
@@ -18,11 +17,9 @@ export function sdkClientFactory(params: ISdkClientFactoryParams): SplitIO.IClie
 
     // Client API (getTreatment* & track methods)
     clientInputValidationDecorator(
-      settings.log,
+      settings,
       clientFactory(params),
-      sdkReadinessManager.readinessManager,
-      // storage is async if and only if mode is consumer or partial consumer
-      [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false,
+      sdkReadinessManager.readinessManager
     ),
 
     // Sdk destroy

package/src/sdkFactory/index.ts

@@ -20,7 +20,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.ISDK | SplitIO.IAsyncSDK {
 
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
-    syncManagerFactory, SignalListener, impressionsObserverFactory, impressionListener,
+    syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory } = params;
   const log = settings.log;
 
@@ -74,8 +74,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   // trackers
   const observer = impressionsObserverFactory && impressionsObserverFactory();
-  const impressionsTracker = impressionsTrackerFactory(log, storage.impressions, settings, impressionListener, integrationsManager, observer, storage.impressionCounts);
-  const eventTracker = eventTrackerFactory(log, storage.events, integrationsManager);
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts);
+  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager);
 
   // signal listener
   const signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);

package/src/sdkFactory/types.ts

@@ -64,7 +64,6 @@ export interface ISdkFactoryParams {
     serviceApi: ISplitApi | undefined) => ISignalListener, // Used by BrowserSignalListener
 
   // @TODO review impressionListener and integrations interfaces. What about handling impressionListener as an integration ?
-  impressionListener?: SplitIO.IImpressionListener,
   integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined,
 
   // Impression observer factory. If provided, will be used for impressions dedupe

package/src/sdkFactory/userConsentProps.ts

@@ -1,7 +1,8 @@
-import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED } from '../logger/constants';
+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) {
@@ -11,20 +12,22 @@ export function userConsentProps(settings: ISettings, syncManager?: ISyncManager
   return {
     setUserConsent(consent: unknown) {
       // validate input param
-      if (typeof consent !== 'boolean') {
-        log.error(ERROR_NOT_BOOLEAN, ['setUserConsent']);
+      if (!isBoolean(consent)) {
+        log.warn(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
+      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;

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/sync/streaming/SSEClient/index.ts

@@ -1,5 +1,6 @@
 import { IEventSourceConstructor } from '../../../services/types';
 import { ISettings } from '../../../types';
+import { isString } from '../../../utils/lang';
 import { IAuthTokenPushEnabled } from '../AuthClient/types';
 import { ISSEClient, ISseEventHandler } from './types';
 
@@ -15,7 +16,7 @@ const CONTROL_CHANNEL_REGEX = /^control_/;
  */
 function buildSSEHeaders(settings: ISettings) {
   const headers: Record<string, string> = {
-    SplitSDKClientKey: settings.core.authorizationKey.slice(-4),
+    SplitSDKClientKey: isString(settings.core.authorizationKey) ? settings.core.authorizationKey.slice(-4) : '',
     SplitSDKVersion: settings.version,
   };
 

package/src/sync/submitters/eventsSyncTask.ts

@@ -22,18 +22,25 @@ export function eventsSyncTaskFactory(
   // don't retry events.
   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 events submitter to be executed when events cache is full

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]);