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

package/src/sdkFactory/types.ts

@@ -64,10 +64,11 @@ 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
   impressionsObserverFactory?: () => IImpressionObserver
 
+  // Optional function to assign additional properties to the factory instance
+  extraProps?: (settings: ISettings, syncManager?: ISyncManager) => object
 }

package/src/sdkFactory/userConsentProps.ts

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

package/src/storages/KeyBuilder.ts

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

package/src/storages/KeyBuilderCS.ts

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

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

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

package/src/storages/inLocalStorage/index.ts

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

package/src/storages/inMemory/ImpressionsCacheInMemory.ts

@@ -3,13 +3,34 @@ import { ImpressionDTO } from '../../types';
 
 export class ImpressionsCacheInMemory implements IImpressionsCacheSync {
 
-  private queue: ImpressionDTO[] = [];
+  private onFullQueue?: () => void;
+  private readonly maxQueue: number;
+  private queue: ImpressionDTO[];
+
+  /**
+   *
+   * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+   * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+   */
+  constructor(impressionsQueueSize: number = 0) {
+    this.maxQueue = impressionsQueueSize;
+    this.queue = [];
+  }
+
+  setOnFullQueueCb(cb: () => void) {
+    this.onFullQueue = cb;
+  }
 
   /**
    * Store impressions in sequential order
    */
   track(data: ImpressionDTO[]) {
     this.queue.push(...data);
+
+    // Check if the cache queue is full and we need to flush it.
+    if (this.maxQueue > 0 && this.queue.length >= this.maxQueue && this.onFullQueue) {
+      this.onFullQueue();
+    }
   }
 
   /**

package/src/storages/inMemory/InMemoryStorage.ts

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

package/src/storages/inMemory/InMemoryStorageCS.ts

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

package/src/storages/inRedis/RedisAdapter.ts

@@ -164,6 +164,12 @@ export class RedisAdapter extends ioredis {
     } else { // If it IS the string URL, that'll be the first param for ioredis.
       result.unshift(options.url);
     }
+    if (options.connectionTimeout) {
+      merge(opts, { connectTimeout: options.connectionTimeout });
+    }
+    if (options.tls) {
+      merge(opts, { tls: options.tls });
+    }
 
     return result;
   }
@@ -171,9 +177,9 @@ export class RedisAdapter extends ioredis {
   /**
    * Parses the options into what we care about.
    */
-  static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass }: Record<string, any>) {
+  static _defineOptions({ connectionTimeout, operationTimeout, url, host, port, db, pass, tls }: Record<string, any>) {
     const parsedOptions = {
-      connectionTimeout, operationTimeout, url, host, port, db, pass
+      connectionTimeout, operationTimeout, url, host, port, db, pass, tls
     };
 
     return merge({}, DEFAULT_OPTIONS, parsedOptions);

package/src/storages/pluggable/index.ts

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

package/src/storages/types.ts

@@ -298,7 +298,7 @@ export interface IRecorderCacheProducerSync<T> {
   // @TODO names are inconsistent with spec
   /* Checks if cache is empty. Returns true if the cache was just created or cleared */
   isEmpty(): boolean
-  /* clears cache data */
+  /* Clears cache data */
   clear(): void
   /* Gets cache data */
   state(): T
@@ -307,10 +307,13 @@ export interface IRecorderCacheProducerSync<T> {
 
 export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheProducerSync<ImpressionDTO[]> {
   track(data: ImpressionDTO[]): void
+  /* Registers callback for full queue */
+  setOnFullQueueCb(cb: () => void): void
 }
 
 export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
   track(data: SplitIO.EventData, size?: number): boolean
+  /* Registers callback for full queue */
   setOnFullQueueCb(cb: () => void): void
 }
 
@@ -423,6 +426,7 @@ export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
 
 export interface IStorageFactoryParams {
   log: ILogger,
+  impressionsQueueSize?: number,
   eventsQueueSize?: number,
   optimize?: boolean /* whether create the `impressionCounts` cache (OPTIMIZED impression mode) or not (DEBUG impression mode) */,
 
@@ -443,7 +447,7 @@ export interface IStorageFactoryParams {
 export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 
 export type IStorageSyncFactory = {
-  type: StorageType,
+  readonly type: StorageType,
   (params: IStorageFactoryParams): IStorageSync
 }
 

package/src/sync/offline/splitsParser/splitsParserFromFile.ts

@@ -82,7 +82,7 @@ export function splitsParserFromFileFactory(): ISplitsParser {
     try {
       data = fs.readFileSync(filePath, 'utf-8');
     } catch (e) {
-      log.error(e.message);
+      log.error(e && (e as Error).message);
 
       return {};
     }

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/streaming/pushManager.ts

@@ -71,6 +71,7 @@ export function pushManagerFactory(
   // It is used to halt the `connectPush` process if it was in progress.
   let disconnected: boolean | undefined;
   // flag that indicates a PUSH_NONRETRYABLE_ERROR, condition with which starting pushManager again is ignored.
+  // true if STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE or Auth errors.
   let disabled: boolean | undefined; // `disabled` implies `disconnected === true`
 
   /** PushManager functions related to initialization */
@@ -296,12 +297,15 @@ export function pushManagerFactory(
     // Expose Event Emitter functionality and Event constants
     Object.create(pushEmitter),
     {
-      // Stop/pause push mode
+      // Stop/pause push mode.
+      // It doesn't emit events. Neither PUSH_SUBSYSTEM_DOWN to start polling.
       stop() {
         disconnectPush(); // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which starts polling.
         if (userKey) this.remove(userKey); // Necessary to properly resume streaming in client-side (e.g., RN SDK transition to foreground).
       },
-      // Start/resume push mode
+
+      // Start/resume push mode.
+      // It eventually emits PUSH_SUBSYSTEM_DOWN, that starts polling, or PUSH_SUBSYSTEM_UP, that executes a syncAll
       start() {
         // Guard condition to avoid calling `connectPush` again if the `start` method is called multiple times or if push has been disabled.
         if (disabled || disconnected === false) return;
@@ -311,6 +315,11 @@ export function pushManagerFactory(
         else setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
       },
 
+      // true/false if start or stop was called last respectively
+      isRunning(){
+        return disconnected === false;
+      },
+
       // [Only for client-side]
       add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask) {
         const hash = hashUserKey(userKey);

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 '../utils/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]);