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

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/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,7 +20,7 @@ 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,
   if (eventsFirstPushWindow > 0) {
@@ -34,10 +36,14 @@ export function eventsSyncTaskFactory(
     };
   }
 
-  // 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/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
@@ -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/consent.ts

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

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/settingsValidation/consent.ts

@@ -0,0 +1,14 @@
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
+import { CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN } from '../constants';
+
+const userConsentValues = [CONSENT_DECLINED, CONSENT_GRANTED, CONSENT_UNKNOWN];
+
+export function validateConsent({ userConsent, log }: { userConsent: any, log: ILogger }) {
+  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/src/utils/settingsValidation/impressionsMode.ts

@@ -1,14 +1,13 @@
-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';
 
-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 {
+  if (typeof impressionsMode === 'string') impressionsMode = impressionsMode.toUpperCase();
 
-  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

@@ -38,6 +38,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,
   },
@@ -95,7 +97,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;
@@ -159,5 +161,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

@@ -20,4 +20,6 @@ export interface ISettingsValidationParams {
   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/integrations/ga/GoogleAnalyticsToSplit.d.ts

@@ -1,3 +1,3 @@
-import { IIntegrationFactoryParams } from '../types';
+import { IntegrationFactory } from '../types';
 import { GoogleAnalyticsToSplitOptions } from './types';
-export declare function GoogleAnalyticsToSplit(options: GoogleAnalyticsToSplitOptions): (params: IIntegrationFactoryParams) => void;
+export declare function GoogleAnalyticsToSplit(options: GoogleAnalyticsToSplitOptions): IntegrationFactory;

package/types/integrations/ga/SplitToGoogleAnalytics.d.ts

@@ -1,4 +1,3 @@
-import { IIntegrationFactoryParams } from '../types';
-import { SplitToGa } from './SplitToGa';
+import { IntegrationFactory } from '../types';
 import { SplitToGoogleAnalyticsOptions } from './types';
-export declare function SplitToGoogleAnalytics(options?: SplitToGoogleAnalyticsOptions): (params: IIntegrationFactoryParams) => SplitToGa;
+export declare function SplitToGoogleAnalytics(options?: SplitToGoogleAnalyticsOptions): IntegrationFactory;

package/types/integrations/types.d.ts

@@ -11,3 +11,7 @@ export interface IIntegrationFactoryParams {
     };
     settings: ISettings;
 }
+export declare type IntegrationFactory = {
+    readonly type: string;
+    (params: IIntegrationFactoryParams): IIntegration | void;
+};

package/types/logger/constants.d.ts

@@ -60,13 +60,14 @@ export declare const STREAMING_RECONNECT = 111;
 export declare const STREAMING_CONNECTING = 112;
 export declare const STREAMING_DISABLED = 113;
 export declare const STREAMING_DISCONNECTING = 114;
-export declare const SUBMITTERS_PUSH_FULL_EVENTS_QUEUE = 115;
+export declare const SUBMITTERS_PUSH_FULL_QUEUE = 115;
 export declare const SUBMITTERS_PUSH = 116;
 export declare const SYNC_START_POLLING = 117;
 export declare const SYNC_CONTINUE_POLLING = 118;
 export declare const SYNC_STOP_POLLING = 119;
 export declare const EVENTS_TRACKER_SUCCESS = 120;
 export declare const IMPRESSIONS_TRACKER_SUCCESS = 121;
+export declare const USER_CONSENT_UPDATED = 122;
 export declare const ENGINE_VALUE_INVALID = 200;
 export declare const ENGINE_VALUE_NO_ATTRIBUTES = 201;
 export declare const CLIENT_NO_LISTENER = 202;
@@ -112,10 +113,11 @@ export declare const ERROR_INVALID_KEY_OBJECT = 317;
 export declare const ERROR_INVALID = 318;
 export declare const ERROR_EMPTY = 319;
 export declare const ERROR_EMPTY_ARRAY = 320;
-export declare const ERROR_INVALID_IMPRESSIONS_MODE = 321;
+export declare const ERROR_INVALID_CONFIG_PARAM = 321;
 export declare const ERROR_HTTP = 322;
 export declare const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export declare const ERROR_STORAGE_INVALID = 324;
+export declare const ERROR_NOT_BOOLEAN = 325;
 export declare const LOG_PREFIX_SETTINGS = "settings";
 export declare const LOG_PREFIX_INSTANTIATION = "Factory instantiation";
 export declare const LOG_PREFIX_ENGINE = "engine";

package/types/logger/types.d.ts

@@ -6,12 +6,12 @@ export interface ILoggerOptions {
 }
 export interface ILogger {
     setLogLevel(logLevel: LogLevel): void;
-    debug(msg: unknown): void;
+    debug(msg: any): void;
     debug(msg: string | number, args?: any[]): void;
-    info(msg: unknown): void;
+    info(msg: any): void;
     info(msg: string | number, args?: any[]): void;
-    warn(msg: unknown): void;
+    warn(msg: any): void;
     warn(msg: string | number, args?: any[]): void;
-    error(msg: unknown): void;
+    error(msg: any): void;
     error(msg: string | number, args?: any[]): void;
 }

package/types/sdkFactory/types.d.ts

@@ -39,4 +39,5 @@ export interface ISdkFactoryParams {
     impressionListener?: SplitIO.IImpressionListener;
     integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined;
     impressionsObserverFactory?: () => IImpressionObserver;
+    extraProps?: (settings: ISettings, syncManager?: ISyncManager) => object;
 }

package/types/sdkFactory/userConsentProps.d.ts

@@ -0,0 +1,6 @@
+import { ISyncManager } from '../sync/types';
+import { ISettings } from '../types';
+export declare function userConsentProps(settings: ISettings, syncManager?: ISyncManager): {
+    setUserConsent(consent: unknown): boolean;
+    getUserConsent(): import("../types").ConsentStatus | undefined;
+};

package/types/storages/KeyBuilderCS.d.ts

@@ -8,6 +8,8 @@ export declare class KeyBuilderCS extends KeyBuilder {
      */
     buildSegmentNameKey(segmentName: string): string;
     extractSegmentName(builtSegmentKeyName: string): string | undefined;
+    buildOldSegmentNameKey(segmentName: string): string;
+    extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
     buildLastUpdatedKey(): string;
     isSplitsCacheKey(key: string): boolean;
     buildSplitsFilterQueryKey(): string;

package/types/storages/inMemory/ImpressionsCacheInMemory.d.ts

@@ -1,7 +1,16 @@
 import { IImpressionsCacheSync } from '../types';
 import { ImpressionDTO } from '../../types';
 export declare class ImpressionsCacheInMemory implements IImpressionsCacheSync {
+    private onFullQueue?;
+    private readonly maxQueue;
     private queue;
+    /**
+     *
+     * @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);
+    setOnFullQueueCb(cb: () => void): void;
     /**
      * Store impressions in sequential order
      */

package/types/storages/types.d.ts

@@ -269,6 +269,7 @@ export interface IRecorderCacheProducerSync<T> {
 }
 export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderCacheProducerSync<ImpressionDTO[]> {
     track(data: ImpressionDTO[]): void;
+    setOnFullQueueCb(cb: () => void): void;
 }
 export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
     track(data: SplitIO.EventData, size?: number): boolean;
@@ -335,6 +336,7 @@ export declare type IStorageAsync = IStorageBase<ISplitsCacheAsync, ISegmentsCac
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
     log: ILogger;
+    impressionsQueueSize?: number;
     eventsQueueSize?: number;
     optimize?: boolean;
     matchingKey?: string;
@@ -345,7 +347,7 @@ export interface IStorageFactoryParams {
 }
 export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {
-    type: StorageType;
+    readonly type: StorageType;
     (params: IStorageFactoryParams): IStorageSync;
 };
 export declare type IStorageAsyncFactory = {

package/types/sync/types.d.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[] = []> {
     /**
@@ -39,6 +40,8 @@ export interface ITimeTracker {
 export interface ISyncManager extends ITask {
     flush(): Promise<any>;
     pushManager?: IPushManager;
+    pollingManager?: IPollingManager;
+    submitter?: ISyncTask;
 }
 export interface ISyncManagerCS extends ISyncManager {
     shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined;

package/types/types.d.ts

@@ -48,6 +48,11 @@ declare type EventConsts = {
  * @typedef {string} SDKMode
  */
 export declare type SDKMode = 'standalone' | 'consumer' | 'localhost' | 'consumer_partial';
+/**
+ * User consent status.
+ * @typedef {string} ConsentStatus
+ */
+export declare 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.
@@ -67,6 +72,7 @@ export interface ISettings {
     readonly scheduler: {
         featuresRefreshRate: number;
         impressionsRefreshRate: number;
+        impressionsQueueSize: number;
         metricsRefreshRate: number;
         segmentsRefreshRate: number;
         offlineRefreshRate: number;
@@ -104,6 +110,7 @@ export interface ISettings {
     };
     readonly log: ILogger;
     readonly impressionListener?: unknown;
+    readonly userConsent?: ConsentStatus;
 }
 /**
  * Log levels.
@@ -249,6 +256,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
@@ -766,6 +780,13 @@ export declare 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/types/utils/consent.d.ts

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

package/types/utils/constants/index.d.ts

@@ -20,3 +20,6 @@ export declare const STORAGE_MEMORY: StorageType;
 export declare const STORAGE_LOCALSTORAGE: StorageType;
 export declare const STORAGE_REDIS: StorageType;
 export declare const STORAGE_PLUGGABLE: StorageType;
+export declare const CONSENT_GRANTED = "GRANTED";
+export declare const CONSENT_DECLINED = "DECLINED";
+export declare const CONSENT_UNKNOWN = "UNKNOWN";

package/types/utils/settingsValidation/consent.d.ts

@@ -0,0 +1,5 @@
+import { ILogger } from '../../logger/types';
+export declare function validateConsent({ userConsent, log }: {
+    userConsent: any;
+    log: ILogger;
+}): any;

package/types/utils/settingsValidation/impressionsMode.d.ts

@@ -1,3 +1,3 @@
 import { ILogger } from '../../logger/types';
 import { SplitIO } from '../../types';
-export declare function validImpressionsMode(log: ILogger, impressionsMode: string): SplitIO.ImpressionsMode;
+export declare function validImpressionsMode(log: ILogger, impressionsMode: any): SplitIO.ImpressionsMode;

package/types/utils/settingsValidation/runtime/browser.d.ts

@@ -1,4 +1,2 @@
-export declare function validateRuntime(): {
-    ip: boolean;
-    hostname: boolean;
-};
+import { ISettings } from '../../../types';
+export declare function validateRuntime(): ISettings['runtime'];