@splitsoftware/splitio-commons 1.2.1-rc.7 → 1.3.0

package/src/evaluator/value/index.ts

@@ -4,7 +4,7 @@ import { ILogger } from '../../logger/types';
 import { sanitize } from './sanitize';
 import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';
 
-function parseValue(log: ILogger, key: string, attributeName: string | null, attributes: SplitIO.Attributes) {
+function parseValue(log: ILogger, key: string, attributeName: string | null, attributes?: SplitIO.Attributes) {
   let value = undefined;
   if (attributeName) {
     if (attributes) {
@@ -23,7 +23,7 @@ function parseValue(log: ILogger, key: string, attributeName: string | null, att
 /**
  * Defines value to be matched (key / attribute).
  */
-export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes: SplitIO.Attributes) {
+export function sanitizeValue(log: ILogger, key: string, matcherDto: IMatcherDto, attributes?: SplitIO.Attributes) {
   const attributeName = matcherDto.attribute;
   const valueToMatch = parseValue(log, key, attributeName, attributes);
   const sanitizedValue = sanitize(log, matcherDto.type, valueToMatch, matcherDto.dataType, attributes);

package/src/evaluator/value/sanitize.ts

@@ -41,7 +41,7 @@ function sanitizeBoolean(val: any): boolean | undefined {
   return undefined;
 }
 
-function dependencyProcessor(sanitizedValue: string, attributes: SplitIO.Attributes): IDependencyMatcherValue {
+function dependencyProcessor(sanitizedValue: string, attributes?: SplitIO.Attributes): IDependencyMatcherValue {
   return {
     key: sanitizedValue,
     attributes
@@ -69,7 +69,7 @@ function getProcessingFunction(matcherTypeID: number, dataType: string) {
 /**
  * Sanitize matcher value
  */
-export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes: SplitIO.Attributes) {
+export function sanitize(log: ILogger, matcherTypeID: number, value: string | number | boolean | Array<string | number> | undefined, dataType: string, attributes?: SplitIO.Attributes) {
   const processor = getProcessingFunction(matcherTypeID, dataType);
   let sanitizedValue: string | number | boolean | Array<string | number> | IDependencyMatcherValue | undefined;
 

package/src/integrations/pluggable.ts

@@ -29,10 +29,10 @@ export function pluggableIntegrationsManagerFactory(
 
   // Exception safe methods: each integration module is responsable for handling errors
   return {
-    handleImpression: function (impressionData: SplitIO.ImpressionData) {
+    handleImpression(impressionData: SplitIO.ImpressionData) {
       listeners.forEach(listener => listener.queue({ type: SPLIT_IMPRESSION, payload: impressionData }));
     },
-    handleEvent: function (eventData: SplitIO.EventData) {
+    handleEvent(eventData: SplitIO.EventData) {
       listeners.forEach(listener => listener.queue({ type: SPLIT_EVENT, payload: eventData }));
     }
   };

package/src/listeners/browser.ts

@@ -11,7 +11,7 @@ import { OPTIMIZED, DEBUG } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
-import { isConsentGranted } from '../utils/consent';
+import { isConsentGranted } from '../consent';
 
 // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
 const UNLOAD_DOM_EVENT = 'unload';

package/src/logger/constants.ts

@@ -70,6 +70,7 @@ 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 USER_CONSENT_INITIAL = 124;
 
 export const ENGINE_VALUE_INVALID = 200;
 export const ENGINE_VALUE_NO_ATTRIBUTES = 201;

package/src/logger/messages/info.ts

@@ -16,6 +16,7 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.IMPRESSIONS_TRACKER_SUCCESS, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Successfully stored %s impression(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).'],
+  [c.USER_CONSENT_INITIAL, 'Starting the SDK with %s user consent. No data will be sent.'],
 
   // synchronizer
   [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],

package/src/sdkClient/client.ts

@@ -4,18 +4,17 @@ 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 { IClientFactoryParams } from './types';
+import { CONTROL } from '../utils/constants';
 import { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
-
+import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
  * Creator of base client with getTreatments and track methods.
  */
 // @TODO missing time tracking to collect telemetry
-export function clientFactory(params: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient {
+export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | SplitIO.IAsyncClient {
   const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker } = params;
   const { log, mode } = settings;
 
@@ -23,7 +22,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 +42,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 +115,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 {
@@ -126,6 +124,6 @@ export function clientFactory(params: IClientFactoryParams): SplitIO.IClient | S
     getTreatments,
     getTreatmentsWithConfig,
     track,
-    isBrowserClient: false
+    isClientSide: false
   } as SplitIO.IClient | SplitIO.IAsyncClient;
 }

package/src/sdkClient/clientCS.ts

@@ -25,6 +25,6 @@ export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: Sp
     // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
     track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
 
-    isBrowserClient: true
+    isClientSide: true
   }) as SplitIO.ICsClient;
 }

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,16 +1,15 @@
 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';
-import { ISdkClientFactoryParams } from './types';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
-export function sdkClientFactory(params: ISdkClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager, syncManager, storage, signalListener, settings, sharedClient } = params;
+export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
+  const { sdkReadinessManager, syncManager, storage, signalListener, settings } = params;
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
@@ -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
@@ -38,7 +35,7 @@ export function sdkClientFactory(params: ISdkClientFactoryParams): SplitIO.IClie
           signalListener && signalListener.stop();
 
           // Release the API Key if it is the main client
-          if (!sharedClient) releaseApiKey(settings.core.authorizationKey);
+          if (!isSharedClient) releaseApiKey(settings.core.authorizationKey);
 
           // Cleanup storage
           return storage.destroy();

package/src/sdkClient/sdkClientMethod.ts

@@ -1,12 +1,12 @@
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
 import { sdkClientFactory } from './sdkClient';
 import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
  * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
  */
-export function sdkClientMethodFactory(params: ISdkClientFactoryParams): () => SplitIO.IClient | SplitIO.IAsyncClient {
+export function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient {
   const log = params.settings.log;
   const clientInstance = sdkClientFactory(params);
 

package/src/sdkClient/sdkClientMethodCS.ts

@@ -1,5 +1,4 @@
 import { clientCSDecorator } from './clientCS';
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { getMatching, keyParser } from '../utils/key';
@@ -8,6 +7,7 @@ import { ISyncManagerCS } from '../sync/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 
 function buildInstanceId(key: SplitIO.SplitKey) {
   // @ts-ignore
@@ -20,18 +20,13 @@ const method = 'Client instantiation';
  * Factory of client method for the client-side API variant where TT is ignored and thus
  * clients don't have a binded TT for the track method.
  */
-export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
+export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
   const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, startup: { readyTimeout }, log } } = params;
 
-  // Keeping similar behaviour as in the isomorphic JS SDK: if settings key is invalid,
-  // `false` value is used as binded key of the default client, but trafficType is ignored
-  // @TODO handle as a non-recoverable error
-  const validKey = validateKey(log, key, method);
-
   const mainClientInstance = clientCSDecorator(
     log,
-    sdkClientFactory(params) as SplitIO.IClient, // @ts-ignore
-    validKey
+    sdkClientFactory(params) as SplitIO.IClient,
+    key
   );
 
   const parsedDefaultKey = keyParser(key);
@@ -81,8 +76,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
-          sharedClient: true
-        })) as SplitIO.IClient,
+        }), true) as SplitIO.IClient,
         validKey
       );
 

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -1,5 +1,4 @@
 import { clientCSDecorator } from './clientCS';
-import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { validateTrafficType } from '../utils/inputValidation/trafficType';
@@ -9,6 +8,7 @@ import { ISyncManagerCS } from '../sync/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
+import { ISdkFactoryContext } from '../sdkFactory/types';
 
 function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
   // @ts-ignore
@@ -22,23 +22,14 @@ const method = 'Client instantiation';
  * where clients can have a binded TT for the track method, which is provided via the settings
  * (default client) or the client method (shared clients).
  */
-export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
+export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
   const { storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, startup: { readyTimeout }, log } } = params;
 
-  // Keeping the behaviour as in the isomorphic JS SDK: if settings key or TT are invalid,
-  // `false` value is used as binded key/TT of the default client, which leads to several issues.
-  // @TODO update when supporting non-recoverable errors
-  const validKey = validateKey(log, key, method);
-  let validTrafficType;
-  if (trafficType !== undefined) {
-    validTrafficType = validateTrafficType(log, trafficType, method);
-  }
-
   const mainClientInstance = clientCSDecorator(
     log,
-    sdkClientFactory(params) as SplitIO.IClient, // @ts-ignore
-    validKey,
-    validTrafficType
+    sdkClientFactory(params) as SplitIO.IClient,
+    key,
+    trafficType
   );
 
   const parsedDefaultKey = keyParser(key);
@@ -95,8 +86,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
-          sharedClient: true
-        })) as SplitIO.IClient,
+        }), true) as SplitIO.IClient,
         validKey,
         validTrafficType
       );

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,14 +74,15 @@ 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);
 
   // Sdk client and manager
-  const clientMethod = sdkClientMethodFactory({ eventTracker, impressionsTracker, sdkReadinessManager, settings, storage, syncManager, signalListener });
+  const ctx = { eventTracker, impressionsTracker, sdkReadinessManager, settings, storage, syncManager, signalListener };
+  const clientMethod = sdkClientMethodFactory(ctx);
   const managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);
 
   syncManager && syncManager.start();
@@ -104,5 +105,5 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     Logger: createLoggerAPI(settings.log),
 
     settings,
-  }, extraProps && extraProps(settings, syncManager));
+  }, extraProps && extraProps(ctx));
 }

package/src/sdkFactory/types.ts

@@ -2,13 +2,23 @@ import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/
 import { ISignalListener } from '../listeners/types';
 import { ILogger } from '../logger/types';
 import { ISdkReadinessManager } from '../readiness/types';
-import { ISdkClientFactoryParams } from '../sdkClient/types';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
+import { IImpressionsTracker, IEventTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
 
+export interface ISdkFactoryContext {
+  storage: IStorageSync | IStorageAsync,
+  sdkReadinessManager: ISdkReadinessManager,
+  settings: ISettings
+  impressionsTracker: IImpressionsTracker,
+  eventTracker: IEventTracker,
+  signalListener?: ISignalListener
+  syncManager?: ISyncManager,
+}
+
 /**
  * Environment related dependencies.
  * These getters are called a fixed number of times per factory instantiation.
@@ -53,7 +63,7 @@ export interface ISdkFactoryParams {
 
   // Sdk client method factory (ISDK::client method).
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).
-  sdkClientMethodFactory: (params: ISdkClientFactoryParams) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
+  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
 
   // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.
   // Pass only if `syncManager` (used by Node listener) and `splitApi` (used by Browser listener) are passed.
@@ -64,12 +74,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
+  extraProps?: (params: ISdkFactoryContext) => object
 }

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

@@ -6,7 +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';
+import { isConsentGranted } from '../consent';
 
 /**
  * Online SyncManager factory.

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

@@ -398,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.

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

@@ -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')
+  );
 }
 
 /**

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