@splitsoftware/splitio-commons 1.0.1-rc.6 → 1.2.1-rc.0

package/src/sdkClient/clientAttributesDecoration.ts

@@ -0,0 +1,122 @@
+import { AttributesCacheInMemory } from '../storages/inMemory/AttributesCacheInMemory';
+import { validateAttributesDeep } from '../utils/inputValidation/attributes';
+import { SplitIO } from '../types';
+import { ILogger } from '../logger/types';
+import { objectAssign } from '../utils/lang/objectAssign';
+
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call 
+ */
+export function clientAttributesDecoration<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient) {
+
+  const attributeStorage = new AttributesCacheInMemory();
+
+  // Keep a reference to the original methods
+  const clientGetTreatment = client.getTreatment;
+  const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
+  const clientGetTreatments = client.getTreatments;
+  const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+  const clientTrack = client.track;
+
+  function getTreatment(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatments(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  }
+
+  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  }
+
+  function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
+    return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
+  }
+
+  function combineAttributes(maybeAttributes: SplitIO.Attributes | undefined): SplitIO.Attributes | undefined{
+    const storedAttributes = attributeStorage.getAll();
+    if (Object.keys(storedAttributes).length > 0) {
+      return objectAssign({}, storedAttributes, maybeAttributes);
+    }
+    return maybeAttributes;
+  }
+
+  return objectAssign(client, {
+    getTreatment: getTreatment,
+    getTreatmentWithConfig: getTreatmentWithConfig,
+    getTreatments: getTreatments,
+    getTreatmentsWithConfig: getTreatmentsWithConfig,
+    track: track,
+    
+    /**
+     * Add an attribute to client's in memory attributes storage
+     * 
+     * @param {string} attributeName Attrinute name
+     * @param {string, number, boolean, list} attributeValue Attribute value
+     * @returns {boolean} true if the attribute was stored and false otherways
+     */
+    setAttribute(attributeName: string, attributeValue: Object) {
+      const attribute: Record<string, Object> = {};
+      attribute[attributeName] = attributeValue;
+      if (!validateAttributesDeep(log, attribute, 'setAttribute')) return false;
+      log.debug(`stored ${attributeValue} for attribute ${attributeName}`);
+      return attributeStorage.setAttribute(attributeName, attributeValue);
+    },
+
+    /**
+     * Returns the attribute with the given key
+     * 
+     * @param {string} attributeName Attribute name
+     * @returns {Object} Attribute with the given key
+     */
+    getAttribute(attributeName: string) {
+      log.debug(`retrieved attribute ${attributeName}`);
+      return attributeStorage.getAttribute(attributeName + '');
+    },
+
+    /**
+     * Add to client's in memory attributes storage the attributes in 'attributes'
+     * 
+     * @param {Object} attributes Object with attributes to store
+     * @returns true if attributes were stored an false otherways
+     */
+    setAttributes(attributes: Record<string, Object>) {
+      if (!validateAttributesDeep(log, attributes, 'setAttributes')) return false;
+      return attributeStorage.setAttributes(attributes);
+    },
+
+    /**
+     * Return all the attributes stored in client's in memory attributes storage
+     * 
+     * @returns {Object} returns all the stored attributes
+     */
+    getAttributes(): Record<string, Object> {
+      return attributeStorage.getAll();
+    },
+
+    /**
+     * Removes from client's in memory attributes storage the attribute with the given key
+     * 
+     * @param {string} attributeName 
+     * @returns {boolean} true if attribute was removed and false otherways
+     */
+    removeAttribute(attributeName: string) {
+      log.debug(`removed attribute ${attributeName}`);
+      return attributeStorage.removeAttribute(attributeName + '');
+    },
+
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes() {
+      return attributeStorage.clear();
+    }
+    
+  });
+
+}

package/src/sdkClient/clientCS.ts

@@ -1,5 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
+import { ILogger } from '../logger/types';
 import { SplitIO } from '../types';
+import { clientAttributesDecoration } from './clientAttributesDecoration';
 
 
 /**
@@ -9,15 +11,20 @@ import { SplitIO } from '../types';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export function clientCSDecorator(client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient {
-  return objectAssign(client, {
+export function clientCSDecorator(log: ILogger, client: SplitIO.IClient, key: SplitIO.SplitKey, trafficType?: string): SplitIO.ICsClient {
+
+  let clientCS = clientAttributesDecoration(log, client);
+
+  return objectAssign(clientCS, {
     // In the client-side API, we bind a key to the client `getTreatment*` methods
-    getTreatment: client.getTreatment.bind(client, key),
-    getTreatmentWithConfig: client.getTreatmentWithConfig.bind(client, key),
-    getTreatments: client.getTreatments.bind(client, key),
-    getTreatmentsWithConfig: client.getTreatmentsWithConfig.bind(client, key),
+    getTreatment: clientCS.getTreatment.bind(clientCS, key),
+    getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
+    getTreatments: clientCS.getTreatments.bind(clientCS, key),
+    getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
 
     // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
-    track: trafficType ? client.track.bind(client, key, trafficType) : client.track.bind(client, key)
+    track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
+
+    isBrowserClient: true
   }) as SplitIO.ICsClient;
 }

package/src/sdkClient/sdkClientMethodCS.ts

@@ -29,6 +29,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
   const validKey = validateKey(log, key, method);
 
   const mainClientInstance = clientCSDecorator(
+    log,
     sdkClientFactory(params) as SplitIO.IClient, // @ts-ignore
     validKey
   );
@@ -74,6 +75,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
       clientInstances[instanceId] = clientCSDecorator(
+        log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -35,6 +35,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
   }
 
   const mainClientInstance = clientCSDecorator(
+    log,
     sdkClientFactory(params) as SplitIO.IClient, // @ts-ignore
     validKey,
     validTrafficType
@@ -88,6 +89,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
       clientInstances[instanceId] = clientCSDecorator(
+        log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,

package/src/sdkFactory/index.ts

@@ -43,8 +43,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     // ATM, only used by PluggableStorage
     mode: settings.mode,
 
-    // Callback used to emit SDK_READY in consumer mode, where `syncManagerFactory` is undefined
-    // or only instantiates submitters, and therefore it is not able to emit readiness events.
+    // Callback used to emit SDK_READY in consumer mode, where `syncManagerFactory` is undefined,
+    // or partial consumer mode, where it only has submitters, and therefore it doesn't emit readiness events.
     onReadyCb: (error) => {
       if (error) return; // Don't emit SDK_READY if storage failed to connect. Error message is logged by wrapperAdapter
       readinessManager.splits.emit(SDK_SPLITS_ARRIVED);

package/src/services/splitHttpClient.ts

@@ -49,7 +49,7 @@ export function splitHttpClientFactory(settings: Pick<ISettings, 'log' | 'versio
         return response;
       })
       .catch(error => {
-        const resp = error.response;
+        const resp = error && error.response;
         let msg = '';
 
         if (resp) { // An HTTP error

package/src/storages/inMemory/AttributesCacheInMemory.ts

@@ -0,0 +1,73 @@
+import { objectAssign } from '../../utils/lang/objectAssign';
+
+export class AttributesCacheInMemory {
+
+  private attributesCache: Record<string, Object> = {};
+
+
+  /**
+   * Create or update the value for the given attribute
+   * 
+   * @param {string} attributeName attribute name
+   * @param {Object} attributeValue attribute value
+   * @returns {boolean} the attribute was stored 
+   */
+  setAttribute(attributeName: string, attributeValue: Object): boolean {
+    this.attributesCache[attributeName] = attributeValue;
+    return true;
+  }
+
+  /**
+   * Retrieves the value of a given attribute
+   * 
+   * @param {string} attributeName attribute name
+   * @returns {Object?} stored attribute value
+   */
+  getAttribute(attributeName: string): Object {
+    return this.attributesCache[attributeName];
+  }
+
+  /**
+   * Create or update all the given attributes
+   * 
+   * @param {[string, Object]} attributes attributes to create or update
+   * @returns {boolean} attributes were stored
+   */
+  setAttributes(attributes: Record<string, Object>): boolean {
+    this.attributesCache = objectAssign(this.attributesCache, attributes);
+    return true;
+  }
+
+  /**
+   * Retrieve the full attributes map
+   * 
+   * @returns {Map<string, Object>} stored attributes
+   */
+  getAll(): Record<string, Object> {
+    return this.attributesCache;
+  }
+
+  /**
+   * Removes a given attribute from the map
+   * 
+   * @param {string} attributeName attribute to remove
+   * @returns {boolean} attribute removed
+   */
+  removeAttribute(attributeName: string): boolean {
+    if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
+      delete this.attributesCache[attributeName];
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Clears all attributes stored in the SDK
+   * 
+   */
+  clear() {
+    this.attributesCache = {};
+    return true;
+  }
+
+}

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

@@ -168,9 +168,12 @@ export function splitChangesUpdaterFactory(
           return false;
         });
 
-      // After triggering the requests, if we have cached splits information let's notify that.
+      // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.
+      // Wrapping in a promise since checkCache can be async.
       if (splitsEventEmitter && startingUp) {
-        Promise.resolve(splits.checkCache()).then(cacheReady => { if (cacheReady) splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED); });
+        Promise.resolve(splits.checkCache()).then(isCacheReady => {
+          if (isCacheReady) splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED);
+        });
       }
       return fetcherPromise;
     }

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

@@ -40,7 +40,7 @@ export function pushManagerFactory(
 
   // `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;
@@ -59,7 +59,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(storage.segments, pollingManager.segmentsSyncTask);
   // 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 +69,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;
@@ -115,7 +111,8 @@ export function pushManagerFactory(
   function connectPush() {
     // Guard condition in case `stop/disconnectPush` has been called (e.g., calling SDK destroy, or app signal close/background)
     if (disconnected) return;
-    log.info(STREAMING_CONNECTING, [disconnected === undefined ? '' : 'Re-']);
+    // @TODO distinguish log for 'Connecting' (1st time) and 'Re-connecting'
+    log.info(STREAMING_CONNECTING);
     disconnected = false;
 
     const userKeys = userKey ? Object.keys(clients) : undefined;
@@ -175,7 +172,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);
@@ -305,37 +302,40 @@ 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
+      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() {
         // 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
       },
 
       // [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/syncManagerOnline.ts

@@ -49,11 +49,11 @@ export function syncManagerOnlineFactory(
     /** 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);
       }
     }
 
@@ -81,6 +81,9 @@ export function syncManagerOnlineFactory(
        * Method used to start the syncManager for the first time, or resume it after being stopped.
        */
       start() {
+        if (running) return;
+        running = true;
+
         // start syncing splits and segments
         if (pollingManager) {
           if (pushManager) {
@@ -96,21 +99,22 @@ export function syncManagerOnlineFactory(
         }
 
         // start periodic data recording (events, impressions, telemetry).
-        submitter && submitter.start();
-        running = true;
+        if (submitter) submitter.start();
       },
 
       /**
        * Method used to stop/pause the syncManager.
        */
       stop() {
+        if (!running) return;
+        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;
       },
 
       isRunning() {

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.
@@ -1108,6 +1112,45 @@ export namespace SplitIO {
      * @returns {boolean} Whether the event was added to the queue succesfully or not.
      */
     track(...args: [trafficType: string, eventType: string, value?: number, properties?: Properties] | [eventType: string, value?: number, properties?: Properties]): boolean,
+    /**
+     * Add an attribute to client's in memory attributes storage
+     * @function setAttribute
+     * @param {string} attributeName Attrinute name
+     * @param {string, number, boolean, list} attributeValue Attribute value
+     * @returns {boolean} true if the attribute was stored and false otherways
+     */
+    setAttribute(attributeName: string, attributeValue: Object): boolean,
+    /**
+     * Returns the attribute with the given key
+     * @function getAttribute
+     * @param {string} attributeName Attribute name
+     * @returns {Object} Attribute with the given key
+     */
+    getAttribute(attributeName: string): Object,
+    /**
+     * Add to client's in memory attributes storage the attributes in 'attributes'
+     * @function setAttributes
+     * @param {Object} attributes Object with attributes to store
+     * @returns true if attributes were stored an false otherways
+     */
+    setAttributes(attributes: Record<string, Object>): boolean,
+    /**
+     * Return all the attributes stored in client's in memory attributes storage
+     * @function getAttributes
+     * @returns {Object} returns all the stored attributes
+     */
+    getAttributes(): Record<string, Object>,
+    /**
+     * Removes from client's in memory attributes storage the attribute with the given key
+     * @function removeAttribute
+     * @param {string} attributeName
+     * @returns {boolean} true if attribute was removed and false otherways
+     */
+    removeAttribute(attributeName: string): boolean,
+    /**
+     * Remove all the stored attributes in the client's in memory attribute storage
+     */
+    clearAttributes(): boolean
   }
   /**
    * Representation of a manager instance with synchronous storage of the SDK.

package/src/utils/inputValidation/attribute.ts

@@ -0,0 +1,21 @@
+import { isString, isFiniteNumber, isBoolean } from '../../utils/lang';
+import { ILogger } from '../../logger/types';
+
+export function validateAttribute(log: ILogger, attributeKey: string, attributeValue: Object, method: string): boolean {
+  if (!isString(attributeKey) || attributeKey.length === 0) {
+    log.warn(`${method}: you passed an invalid attribute name, attribute name must be a non-empty string.`);
+    return false;
+  }
+
+  const isStringVal = isString(attributeValue);
+  const isFiniteVal = isFiniteNumber(attributeValue);
+  const isBoolVal = isBoolean(attributeValue);
+  const isArrayVal = Array.isArray(attributeValue);
+
+  if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) { // If it's not of valid type.
+    log.warn(`${method}: you passed an invalid attribute value for ${attributeKey}. Acceptable types are: string, number, boolean and array of strings.`);
+    return false;
+  }
+
+  return true;
+}

package/src/utils/inputValidation/attributes.ts

@@ -1,6 +1,7 @@
 import { isObject } from '../lang';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
+import { validateAttribute } from './attribute';
 import { ERROR_NOT_PLAIN_OBJECT } from '../../logger/constants';
 
 export function validateAttributes(log: ILogger, maybeAttrs: any, method: string): SplitIO.Attributes | undefined | false {
@@ -11,3 +12,16 @@ export function validateAttributes(log: ILogger, maybeAttrs: any, method: string
   log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'attributes']);
   return false;
 }
+
+export function validateAttributesDeep(log: ILogger, maybeAttributes: Record<string, Object>, method: string): boolean {
+  if (!validateAttributes(log, maybeAttributes, method)) return false;
+
+  let result = true;
+  Object.keys(maybeAttributes).forEach(attributeKey => {
+    if (!validateAttribute(log, attributeKey, maybeAttributes[attributeKey], method))
+      result = false;
+  });
+
+  return result;
+
+}

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

@@ -122,7 +122,7 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // Startup periods
   startup.requestTimeoutBeforeReady = fromSecondsToMillis(startup.requestTimeoutBeforeReady);
   startup.readyTimeout = fromSecondsToMillis(startup.readyTimeout);
-  startup.eventsFirstPushWindow = fromSecondsToMillis(withDefaults.startup.eventsFirstPushWindow);
+  startup.eventsFirstPushWindow = fromSecondsToMillis(startup.eventsFirstPushWindow);
 
   // ensure a valid SDK mode
   // @ts-ignore, modify readonly prop