@splitsoftware/splitio-commons 1.2.0 → 1.2.1-rc.3

package/src/sync/polling/syncTasks/mySegmentsSyncTask.ts

@@ -21,12 +21,13 @@ export function mySegmentsSyncTaskFactory(
     settings.log,
     mySegmentsUpdaterFactory(
       settings.log,
-      mySegmentsFetcherFactory(fetchMySegments, matchingKey),
+      mySegmentsFetcherFactory(fetchMySegments),
       storage.splits,
       storage.segments,
       readiness.segments,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,
+      matchingKey
     ),
     settings.scheduler.segmentsRefreshRate,
     'mySegmentsUpdater',

package/src/sync/polling/types.ts

@@ -1,7 +1,5 @@
 import { IReadinessManager } from '../../readiness/types';
-import { ISplitApi } from '../../services/types';
 import { IStorageSync } from '../../storages/types';
-import { ISettings } from '../../types';
 import { SegmentsData } from '../streaming/SSEHandler/types';
 import { ITask, ISyncTask } from '../types';
 
@@ -23,13 +21,3 @@ export interface IPollingManagerCS extends IPollingManager {
   remove(matchingKey: string): void;
   get(matchingKey: string): ISegmentsSyncTask | undefined
 }
-
-/**
- * Signature of polling manager factory/constructor
- */
-export type IPollingManagerFactoryParams = [
-  splitApi: ISplitApi,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  settings: ISettings,
-]

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -23,6 +23,7 @@ export function mySegmentsUpdaterFactory(
   segmentsEventEmitter: ISegmentsEventEmitter,
   requestTimeoutBeforeReady: number,
   retriesOnFailureBeforeReady: number,
+  matchingKey: string
 ): IMySegmentsUpdater {
 
   let readyOnAlreadyExistentState = true;
@@ -69,7 +70,7 @@ export function mySegmentsUpdaterFactory(
       // If segmentsData is provided, there is no need to fetch mySegments
       new Promise((res) => { updateSegments(segmentsData); res(true); }) :
       // If not provided, fetch mySegments
-      mySegmentsFetcher(noCache, _promiseDecorator).then(segments => {
+      mySegmentsFetcher(matchingKey, noCache, _promiseDecorator).then(segments => {
         // Only when we have downloaded segments completely, we should not keep retrying anymore
         startingUp = false;
 

package/src/sync/streaming/AuthClient/index.ts

@@ -17,8 +17,7 @@ export function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate {
    * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for server-side API.
    */
   return function authenticate(userKeys?: string[]): Promise<IAuthToken> {
-    let authPromise = fetchAuth(userKeys); // errors handled by fetchAuth service
-    return authPromise
+    return fetchAuth(userKeys)
       .then(resp => resp.json())
       .then(json => {
         if (json.token) { // empty token when `"pushEnabled": false`

package/src/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.ts

@@ -19,7 +19,7 @@ export class SegmentsUpdateWorker implements IUpdateWorker {
    * @param {Object} segmentsCache segments data cache
    * @param {Object} segmentsSyncTask task for syncing segments data
    */
-  constructor(segmentsCache: ISegmentsCacheSync, segmentsSyncTask: ISegmentsSyncTask) {
+  constructor(segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync) {
     this.segmentsCache = segmentsCache;
     this.segmentsSyncTask = segmentsSyncTask;
     this.maxChangeNumbers = {};

package/src/sync/streaming/pushManager.ts

@@ -1,7 +1,5 @@
-import { IPushEventEmitter, IPushManagerCS } from './types';
+import { IPushEventEmitter, IPushManager } from './types';
 import { ISSEClient } from './SSEClient/types';
-import { IStorageSync } from '../../storages/types';
-import { IReadinessManager } from '../../readiness/types';
 import { ISegmentsSyncTask, IPollingManager } from '../polling/types';
 import { objectAssign } from '../../utils/lang/objectAssign';
 import { Backoff } from '../../utils/Backoff';
@@ -12,17 +10,15 @@ import { SplitsUpdateWorker } from './UpdateWorkers/SplitsUpdateWorker';
 import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
-import { IFetchAuth } from '../../services/types';
-import { ISettings } from '../../types';
 import { getMatching } from '../../utils/key';
 import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
-import { IPlatform } from '../../sdkFactory/types';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 } from '../../logger/constants';
 import { KeyList, UpdateStrategy } from './SSEHandler/types';
 import { isInBitmap, parseBitmap, parseKeyList } from './mySegmentsV2utils';
 import { ISet, _Set } from '../../utils/lang/sets';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
+import { ISyncManagerFactoryParams } from '../types';
 
 /**
  * PushManager factory:
@@ -30,17 +26,15 @@ import { IAuthTokenPushEnabled } from './AuthClient/types';
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
 export function pushManagerFactory(
+  params: ISyncManagerFactoryParams,
   pollingManager: IPollingManager,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  fetchAuth: IFetchAuth,
-  platform: IPlatform,
-  settings: ISettings,
-): IPushManagerCS | undefined {
+): IPushManager | undefined {
+
+  const { settings, storage, splitApi, readiness, platform } = params;
 
   // `userKey` is the matching key of main client in client-side SDK.
   // It can be used to check if running on client-side or server-side SDK.
-  const userKey = settings.core.key ? getMatching(settings.core.key) : undefined; //
+  const userKey = settings.core.key ? getMatching(settings.core.key) : undefined;
   const log = settings.log;
 
   let sseClient: ISSEClient;
@@ -51,7 +45,7 @@ export function pushManagerFactory(
     log.warn(STREAMING_FALLBACK, [e]);
     return;
   }
-  const authenticate = authenticateFactory(fetchAuth);
+  const authenticate = authenticateFactory(splitApi.fetchAuth);
 
   // init feedback loop
   const pushEmitter = new platform.EventEmitter() as IPushEventEmitter;
@@ -59,7 +53,8 @@ export function pushManagerFactory(
   sseClient.setEventHandler(sseHandler);
 
   // init workers
-  const segmentsUpdateWorker = userKey ? new MySegmentsUpdateWorker(pollingManager.segmentsSyncTask) : new SegmentsUpdateWorker(storage.segments, pollingManager.segmentsSyncTask);
+  // MySegmentsUpdateWorker (client-side) are initiated in `add` method
+  const segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
   // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
   const splitsUpdateWorker = new SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
 
@@ -68,11 +63,6 @@ export function pushManagerFactory(
   // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
   // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
   const clients: Record<string, { hash64: Hash64, worker: MySegmentsUpdateWorker }> = {};
-  if (userKey) {
-    const hash = hashUserKey(userKey);
-    userKeyHashes[hash] = userKey;
-    clients[userKey] = { hash64: hash64(userKey), worker: segmentsUpdateWorker as MySegmentsUpdateWorker };
-  }
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
@@ -81,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 */
@@ -176,7 +167,7 @@ export function pushManagerFactory(
   function stopWorkers() {
     splitsUpdateWorker.backoff.reset();
     if (userKey) forOwn(clients, ({ worker }) => worker.backoff.reset());
-    else segmentsUpdateWorker.backoff.reset();
+    else (segmentsUpdateWorker as SegmentsUpdateWorker).backoff.reset();
   }
 
   pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
@@ -306,37 +297,48 @@ export function pushManagerFactory(
     // Expose Event Emitter functionality and Event constants
     Object.create(pushEmitter),
     {
-      // Expose functionality for starting and stoping push mode:
-      stop: disconnectPush, // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which starts polling.
+      // 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.
+      // 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;
         disconnected = false;
-        // Run in next event-loop cycle for optimization on client-side: if multiple clients are created in the same cycle than the factory, only one authentication is performed.
-        setTimeout(connectPush);
+
+        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask); // client-side
+        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) {
-        clients[userKey] = { hash64: hash64(userKey), worker: new MySegmentsUpdateWorker(mySegmentsSyncTask) };
-
         const hash = hashUserKey(userKey);
 
         if (!userKeyHashes[hash]) {
           userKeyHashes[hash] = userKey;
+          clients[userKey] = { hash64: hash64(userKey), worker: new MySegmentsUpdateWorker(mySegmentsSyncTask) };
           connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
-        }
 
-        // Reconnects in case of a new client.
-        // Run in next event-loop cycle to save authentication calls
-        // in case the user is creating several clients in the current cycle.
-        setTimeout(function checkForReconnect() {
-          if (connectForNewClient) {
-            connectForNewClient = false;
-            connectPush();
-          }
-        }, 0);
+          // Reconnects in case of a new client.
+          // Run in next event-loop cycle to save authentication calls
+          // in case multiple clients are created in the current cycle.
+          setTimeout(function checkForReconnect() {
+            if (connectForNewClient) {
+              connectForNewClient = false;
+              connectPush();
+            }
+          }, 0);
+        }
       },
       // [Only for client-side]
       remove(userKey: string) {

package/src/sync/streaming/types.ts

@@ -1,11 +1,7 @@
 import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
 import { ITask } from '../types';
-import { IPollingManager, ISegmentsSyncTask } from '../polling/types';
-import { IReadinessManager } from '../../readiness/types';
-import { IFetchAuth } from '../../services/types';
-import { IStorageSync } from '../../storages/types';
-import { IEventEmitter, ISettings } from '../../types';
-import { IPlatform } from '../../sdkFactory/types';
+import { ISegmentsSyncTask } from '../polling/types';
+import { IEventEmitter } from '../../types';
 import { ControlType } from './constants';
 
 // Internal SDK events, subscribed by SyncManager and PushManager
@@ -45,26 +41,10 @@ export interface IPushEventEmitter extends IEventEmitter {
 }
 
 /**
- * PushManager for server-side
+ * PushManager
  */
-export interface IPushManager extends ITask, IPushEventEmitter { }
-
-/**
- * PushManager for client-side with support for multiple clients
- */
-export interface IPushManagerCS extends IPushManager {
+export interface IPushManager extends ITask, IPushEventEmitter {
+  // Methods used in client-side, to support multiple clients
   add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask): void,
   remove(userKey: string): void
 }
-
-/**
- * Signature of push manager factory/constructor
- */
-export type IPushManagerFactoryParams = [
-  pollingManager: IPollingManager,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
-  fetchAuth: IFetchAuth,
-  platform: IPlatform,
-  settings: ISettings
-]

package/src/sync/submitters/submitterManager.ts

@@ -2,15 +2,11 @@ import { syncTaskComposite } from '../syncTaskComposite';
 import { eventsSyncTaskFactory } from './eventsSyncTask';
 import { impressionsSyncTaskFactory } from './impressionsSyncTask';
 import { impressionCountsSyncTaskFactory } from './impressionCountsSyncTask';
-import { ISplitApi } from '../../services/types';
-import { IStorageSync } from '../../storages/types';
-import { ISettings } from '../../types';
+import { ISyncManagerFactoryParams } from '../types';
 
-export function submitterManagerFactory(
-  settings: ISettings,
-  storage: IStorageSync,
-  splitApi: ISplitApi,
-) {
+export function submitterManagerFactory(params: ISyncManagerFactoryParams) {
+
+  const { settings, storage, splitApi } = params;
   const log = settings.log;
   const submitters = [
     impressionsSyncTaskFactory(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),

package/src/sync/syncManagerOnline.ts

@@ -2,8 +2,8 @@ import { ISyncManagerCS, ISyncManagerFactoryParams } from './types';
 import { submitterManagerFactory } from './submitters/submitterManager';
 import { IReadinessManager } from '../readiness/types';
 import { IStorageSync } from '../storages/types';
-import { IPushManagerFactoryParams, IPushManager, IPushManagerCS } from './streaming/types';
-import { IPollingManager, IPollingManagerCS, IPollingManagerFactoryParams } from './polling/types';
+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';
 
@@ -16,44 +16,38 @@ import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '..
  * @param pushManagerFactory optional to build a SyncManager with or without streaming support
  */
 export function syncManagerOnlineFactory(
-  pollingManagerFactory?: (...args: IPollingManagerFactoryParams) => IPollingManager,
-  pushManagerFactory?: (...args: IPushManagerFactoryParams) => IPushManager | undefined
+  pollingManagerFactory?: (params: ISyncManagerFactoryParams) => IPollingManager,
+  pushManagerFactory?: (params: ISyncManagerFactoryParams, pollingManager: IPollingManager) => IPushManager | undefined,
 ): (params: ISyncManagerFactoryParams) => ISyncManagerCS {
 
   /**
    * SyncManager factory for modular SDK
    */
-  return function ({
-    settings,
-    platform,
-    splitApi,
-    storage,
-    readiness
-  }: ISyncManagerFactoryParams): ISyncManagerCS {
+  return function (params: ISyncManagerFactoryParams): ISyncManagerCS {
 
-    const log = settings.log;
+    const { log, streamingEnabled } = params.settings;
 
     /** Polling Manager */
-    const pollingManager = pollingManagerFactory && pollingManagerFactory(splitApi, storage, readiness, settings);
+    const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
 
     /** Push Manager */
-    const pushManager = settings.streamingEnabled && pollingManager && pushManagerFactory ?
-      pushManagerFactory(pollingManager, storage, readiness, splitApi.fetchAuth, platform, settings) :
+    const pushManager = streamingEnabled && pollingManager && pushManagerFactory ?
+      pushManagerFactory(params, pollingManager) :
       undefined;
 
     /** Submitter Manager */
     // It is not inyected as push and polling managers, because at the moment it is required
-    const submitter = submitterManagerFactory(settings, storage, splitApi);
+    const submitter = submitterManagerFactory(params);
 
 
     /** Sync Manager logic */
 
     function startPolling() {
-      if (!pollingManager!.isRunning()) {
+      if (pollingManager!.isRunning()) {
+        log.info(SYNC_CONTINUE_POLLING);
+      } else {
         log.info(SYNC_START_POLLING);
         pollingManager!.start();
-      } else {
-        log.info(SYNC_CONTINUE_POLLING);
       }
     }
 
@@ -96,7 +90,7 @@ export function syncManagerOnlineFactory(
         }
 
         // start periodic data recording (events, impressions, telemetry).
-        submitter && submitter.start();
+        if (submitter) submitter.start();
         running = true;
       },
 
@@ -141,7 +135,7 @@ export function syncManagerOnlineFactory(
                 // of segments since `syncAll` was already executed when starting the main client
                 mySegmentsSyncTask.execute();
               }
-              (pushManager as IPushManagerCS).add(matchingKey, mySegmentsSyncTask);
+              pushManager.add(matchingKey, mySegmentsSyncTask);
             } else {
               if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
             }
@@ -151,7 +145,7 @@ export function syncManagerOnlineFactory(
             const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).get(matchingKey);
             if (mySegmentsSyncTask) {
               // stop syncing
-              if (pushManager) (pushManager as IPushManagerCS).remove(matchingKey);
+              if (pushManager) pushManager.remove(matchingKey);
               if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
 
               (pollingManager as IPollingManagerCS).remove(matchingKey);

package/src/types.ts

@@ -381,6 +381,10 @@ interface IBasicClient extends IStatusInterface {
    * @returns {Promise<void>}
    */
   destroy(): Promise<void>
+
+  // 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
 }
 /**
  * Common definitions between SDK instances for different environments interface.
@@ -1139,7 +1143,7 @@ export namespace SplitIO {
     /**
      * Removes from client's in memory attributes storage the attribute with the given key
      * @function removeAttribute
-     * @param {string} attributeName 
+     * @param {string} attributeName
      * @returns {boolean} true if attribute was removed and false otherways
      */
     removeAttribute(attributeName: string): boolean,

package/src/utils/inputValidation/eventProperties.ts

@@ -1,4 +1,5 @@
-import { isObject, shallowClone, isString, isFiniteNumber, isBoolean } from '../lang';
+import { isObject, isString, isFiniteNumber, isBoolean } from '../lang';
+import { objectAssign } from '../lang/objectAssign';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
 import { ERROR_NOT_PLAIN_OBJECT, ERROR_SIZE_EXCEEDED, WARN_SETTING_NULL, WARN_TRIMMING_PROPERTIES } from '../../logger/constants';
@@ -22,7 +23,8 @@ export function validateEventProperties(log: ILogger, maybeProperties: any, meth
   }
 
   const keys = Object.keys(maybeProperties);
-  const clone = shallowClone(maybeProperties);
+  // Shallow clone
+  const clone = objectAssign({}, maybeProperties);
   // To avoid calculating the size twice we'll return it from here.
   const output = {
     properties: clone,

package/src/utils/lang/index.ts

@@ -194,20 +194,6 @@ export function merge(target: { [key: string]: any }, source: { [key: string]: a
   return res;
 }
 
-/**
- * Shallow clone an object
- */
-export function shallowClone(obj: any): any {
-  const keys = Object.keys(obj);
-  const output: Record<string, any> = {};
-
-  for (let i = 0; i < keys.length; i++) {
-    output[keys[i]] = obj[keys[i]];
-  }
-
-  return output;
-}
-
 /**
  * Checks if the target string starts with the sub string.
  */

package/src/utils/murmur3/legacy.ts

@@ -0,0 +1,48 @@
+// Deprecated hashing function, used for split bucketing. Replaced by murmur3
+
+//
+// JAVA reference implementation for the hashing function.
+//
+// int h = 0;
+// for (int i = 0; i < key.length(); i++) {
+//     h = 31 * h + key.charAt(i);
+// }
+// return h ^ seed; // XOR the hash and seed
+//
+
+function ToInteger(x: number) {
+  x = Number(x);
+  return x < 0 ? Math.ceil(x) : Math.floor(x);
+}
+
+function modulo(a: number, b: number) {
+  return a - Math.floor(a / b) * b;
+}
+
+function ToUint32(x: number) {
+  return modulo(ToInteger(x), Math.pow(2, 32));
+}
+
+function ToInt32(x: number) {
+  let uint32 = ToUint32(x);
+
+  if (uint32 >= Math.pow(2, 31)) {
+    return uint32 - Math.pow(2, 32);
+  } else {
+    return uint32;
+  }
+}
+
+export function hash(str: string, seed: number): number {
+  let h = 0;
+
+  for (let i = 0; i < str.length; i++) {
+    h = ToInt32(ToInt32(31 * h) + str.charCodeAt(i));
+  }
+
+  return ToInt32(h ^ seed);
+}
+
+export function bucket(str: string, seed: number): number {
+  return Math.abs(hash(str, seed) % 100) + 1;
+}

package/src/utils/promise/timeout.ts

@@ -3,7 +3,7 @@ export function timeout<T>(ms: number, promise: Promise<T>): Promise<T> {
 
   return new Promise((resolve, reject) => {
     const tid = setTimeout(() => {
-      reject(new Error(`Operation timed out because it exceeded the configured time limit of ${ms}ms.`));
+      reject(new Error(`Operation timed out because it exceeded the configured time limit of ${ms} ms.`));
     }, ms);
 
     promise.then((res) => {

package/src/utils/settingsValidation/index.ts

@@ -78,11 +78,6 @@ const base = {
     localhostMode: undefined
   },
 
-  runtime: {
-    ip: false,
-    hostname: false
-  },
-
   // Logger
   log: undefined
 };
@@ -139,7 +134,7 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
 
   // Current ip/hostname information
   // @ts-ignore, modify readonly prop
-  if (runtime) withDefaults.runtime = runtime(withDefaults);
+  withDefaults.runtime = runtime(withDefaults);
 
   // ensure a valid list of integrations.
   // `integrations` returns an array of valid integration items.

package/src/utils/settingsValidation/runtime/browser.ts

@@ -0,0 +1,8 @@
+import { ISettings } from '../../../types';
+
+export function validateRuntime(): ISettings['runtime'] {
+  return {
+    ip: false,
+    hostname: false
+  };
+}

package/src/utils/settingsValidation/runtime/node.ts

@@ -0,0 +1,22 @@
+import osFunction from 'os';
+import ipFunction from 'ip';
+
+import { UNKNOWN, NA, CONSUMER_MODE } from '../../constants';
+import { ISettings } from '../../../types';
+
+export function validateRuntime(settings: ISettings): ISettings['runtime'] {
+  const isIPAddressesEnabled = settings.core.IPAddressesEnabled === true;
+  const isConsumerMode = settings.mode === CONSUMER_MODE;
+
+  // If the values are not available, default to false (for standalone) or "unknown" (for consumer mode, to be used on Redis keys)
+  let ip = ipFunction.address() || (isConsumerMode ? UNKNOWN : false);
+  let hostname = osFunction.hostname() || (isConsumerMode ? UNKNOWN : false);
+
+  if (!isIPAddressesEnabled) { // If IPAddresses setting is not enabled, set as false (for standalone) or "NA" (for consumer mode, to  be used on Redis keys)
+    ip = hostname = isConsumerMode ? NA : false;
+  }
+
+  return {
+    ip, hostname
+  };
+}

package/src/utils/settingsValidation/types.ts

@@ -6,15 +6,15 @@ import { ISettings } from '../../types';
  */
 export interface ISettingsValidationParams {
   /**
-   * Object of values to overwrite default settings.
-   * Version and startup properties are mandatory, because these values are not part of the base setting.
+   * Object of values to overwrite base settings.
+   * Version and startup properties are required, because they are not defined in the base settings.
    */
   defaults: Partial<ISettings> & { version: string } & { startup: ISettings['startup'] },
-  /** Function to overwrite runtime values (ip and hostname) which are false by default */
-  runtime?: (settings: ISettings) => ISettings['runtime'],
-  /** Storage validator */
+  /** Function to define runtime values (`settings.runtime`) */
+  runtime: (settings: ISettings) => ISettings['runtime'],
+  /** Storage validator (`settings.storage`) */
   storage?: (settings: ISettings) => ISettings['storage'],
-  /** Integrations validator */
+  /** Integrations validator (`settings.integrations`) */
   integrations?: (settings: ISettings) => ISettings['integrations'],
   /** Logger validator (`settings.debug`) */
   logger: (settings: ISettings) => ISettings['log'],

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

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

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/SplitToGaPlugin.d.ts

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

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/codes.d.ts

@@ -0,0 +1,2 @@
+import { ICodes } from './types';
+export declare const codes: ICodes;