@splitsoftware/splitio-commons 1.0.1-rc.4 → 1.1.1-rc.0

package/src/logger/messages/warn.ts

@@ -21,9 +21,9 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.WARN_TRIMMING_PROPERTIES, '%s: Event has more than 300 properties. Some of them will be trimmed when processed.'],
   [c.WARN_CONVERTING, '%s: %s "%s" is not of type string, converting.'],
   [c.WARN_TRIMMING, '%s: %s "%s" has extra whitespace, trimming.'],
-  [c.WARN_NOT_EXISTENT_SPLIT, '%s: split "%s" does not exist in this environment, please double check what splits exist in the web console.'],
+  [c.WARN_NOT_EXISTENT_SPLIT, '%s: split "%s" does not exist in this environment, please double check what splits exist in the Split web console.'],
   [c.WARN_LOWERCASE_TRAFFIC_TYPE, '%s: traffic_type_name should be all lowercase - converting string to lowercase.'],
-  [c.WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding split in this environment, make sure you\'re tracking your events to a valid traffic type defined in the web console.'],
+  [c.WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding split in this environment, make sure you\'re tracking your events to a valid traffic type defined in the Split web console.'],
   // initialization / settings validation
   [c.WARN_INTEGRATION_INVALID, c.LOG_PREFIX_SETTINGS+': %s integration item(s) at settings is invalid. %s'],
   [c.WARN_SPLITS_FILTER_IGNORED, c.LOG_PREFIX_SETTINGS+': split filters have been configured but will have no effect if mode is not "%s", since synchronization is being deferred to an external tool.'],

package/src/readiness/readinessManager.ts

@@ -1,4 +1,4 @@
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 import { IEventEmitter } from '../types';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
 import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, ISplitsEventEmitter } from './types';
@@ -12,7 +12,7 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
   // - `/mySegments` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
   // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
-  splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (isSplitKill) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
+  splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (isSplitKill: boolean) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
   splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, () => { splitsEventEmitter.splitsCacheLoaded = true; });
 
   return splitsEventEmitter;

package/src/readiness/sdkReadinessManager.ts

@@ -1,5 +1,5 @@
-import objectAssign from 'object-assign';
-import promiseWrapper from '../utils/promise/wrapper';
+import { objectAssign } from '../utils/lang/objectAssign';
+import { promiseWrapper } from '../utils/promise/wrapper';
 import { readinessManagerFactory } from './readinessManager';
 import { ISdkReadinessManager } from './types';
 import { IEventEmitter } from '../types';
@@ -19,7 +19,7 @@ const REMOVE_LISTENER_EVENT = 'removeListener';
  * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-export default function sdkReadinessManagerFactory(
+export function sdkReadinessManagerFactory(
   log: ILogger,
   EventEmitter: new () => IEventEmitter,
   readyTimeout = 0,

package/src/sdkClient/client.ts

@@ -1,5 +1,5 @@
 import { evaluateFeature, evaluateFeatures } from '../evaluator';
-import thenable from '../utils/promise/thenable';
+import { thenable } from '../utils/promise/thenable';
 import { getMatching, getBucketing } from '../utils/key';
 import { validateSplitExistance } from '../utils/inputValidation/splitExistance';
 import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';
@@ -15,7 +15,7 @@ import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
  * Creator of base client with getTreatments and track methods.
  */
 // @TODO missing time tracking to collect telemetry
-export default function clientFactory(params: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient {
+export function clientFactory(params: IClientFactoryParams): SplitIO.IClient | SplitIO.IAsyncClient {
   const { sdkReadinessManager: { readinessManager }, storage, settings: { log, mode }, impressionsTracker, eventTracker } = params;
 
   function getTreatment(key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, withConfig = false) {

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 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
+import { ILogger } from '../logger/types';
 import { SplitIO } from '../types';
+import { clientAttributesDecoration } from './clientAttributesDecoration';
 
 
 /**
@@ -9,15 +11,18 @@ import { SplitIO } from '../types';
  * @param key validated split key
  * @param trafficType validated traffic type
  */
-export default 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)
   }) as SplitIO.ICsClient;
 }

package/src/sdkClient/clientInputValidation.ts

@@ -1,4 +1,4 @@
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 import {
   validateAttributes,
   validateEvent,
@@ -22,7 +22,7 @@ import { ILogger } from '../logger/types';
  * 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 default 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>(log: ILogger, client: TClient, readinessManager: IReadinessManager, isStorageSync = false): TClient {
 
   /**
    * Avoid repeating this validations code

package/src/sdkClient/sdkClient.ts

@@ -1,9 +1,9 @@
-import objectAssign from 'object-assign';
+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 { clientFactory } from './client';
+import { clientInputValidationDecorator } from './clientInputValidation';
 import { ISdkClientFactoryParams } from './types';
 
 /**

package/src/sdkClient/sdkClientMethodCS.ts

@@ -1,11 +1,11 @@
-import clientCSDecorator from './clientCS';
+import { clientCSDecorator } from './clientCS';
 import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { getMatching, keyParser } from '../utils/key';
 import { sdkClientFactory } from './sdkClient';
 import { ISyncManagerCS } from '../sync/types';
-import objectAssign from 'object-assign';
+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';
 
@@ -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

@@ -1,4 +1,4 @@
-import clientCSDecorator from './clientCS';
+import { clientCSDecorator } from './clientCS';
 import { ISdkClientFactoryParams } from './types';
 import { SplitIO } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
@@ -6,7 +6,7 @@ import { validateTrafficType } from '../utils/inputValidation/trafficType';
 import { getMatching, keyParser } from '../utils/key';
 import { sdkClientFactory } from './sdkClient';
 import { ISyncManagerCS } from '../sync/types';
-import objectAssign from 'object-assign';
+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';
 
@@ -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

@@ -1,7 +1,7 @@
 import { ISdkFactoryParams } from './types';
-import sdkReadinessManagerFactory from '../readiness/sdkReadinessManager';
-import impressionsTrackerFactory from '../trackers/impressionsTracker';
-import eventTrackerFactory from '../trackers/eventTracker';
+import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
+import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
+import { eventTrackerFactory } from '../trackers/eventTracker';
 import { IStorageFactoryParams, IStorageSync } from '../storages/types';
 import { SplitIO } from '../types';
 import { ISplitApi } from '../services/types';
@@ -43,10 +43,10 @@ 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.
+      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);
       readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
     },

package/src/sdkManager/index.ts

@@ -1,5 +1,5 @@
-import objectAssign from 'object-assign';
-import thenable from '../utils/promise/thenable';
+import { objectAssign } from '../utils/lang/objectAssign';
+import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
 import { validateSplit, validateSplitExistance, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';

package/src/services/splitApi.ts

@@ -2,7 +2,7 @@ import { IPlatform } from '../sdkFactory/types';
 import { ISettings } from '../types';
 import { splitHttpClientFactory } from './splitHttpClient';
 import { ISplitApi } from './types';
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 

package/src/services/splitHttpClient.ts

@@ -1,5 +1,5 @@
 import { IFetch, IRequestOptions, IResponse, ISplitHttpClient } from './types';
-import objectAssign from 'object-assign';
+import { objectAssign } from '../utils/lang/objectAssign';
 import { ERROR_HTTP, ERROR_CLIENT_CANNOT_GET_READY } from '../logger/constants';
 import { ISettings } from '../types';
 

package/src/storages/AbstractSegmentsCacheSync.ts

@@ -6,7 +6,7 @@ import { ISegmentsCacheSync } from './types';
  * This class provides a skeletal implementation of the ISegmentsCacheSync interface
  * to minimize the effort required to implement this interface.
  */
-export default abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
+export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
   /**
    * For server-side synchronizer: add `segmentKeys` list of keys to `name` segment.
    * For client-side synchronizer: add `name` segment to the cache. `segmentKeys` is undefined.

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -5,7 +5,7 @@ import { ISplit } from '../dtos/types';
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
  * to minimize the effort required to implement this interface.
  */
-export default abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
+export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
 
   abstract addSplit(name: string, split: string): Promise<boolean>
   abstract addSplits(entries: [string, string][]): Promise<boolean[] | void>

package/src/storages/AbstractSplitsCacheSync.ts

@@ -5,7 +5,7 @@ import { ISplit } from '../dtos/types';
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
  * to minimize the effort required to implement this interface.
  */
-export default abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
+export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   abstract addSplit(name: string, split: string): boolean;
 

package/src/storages/KeyBuilder.ts

@@ -12,7 +12,7 @@ export function validatePrefix(prefix: unknown) {
     DEFAULT_PREFIX; // use default prefix if none is provided
 }
 
-export default class KeyBuilder {
+export class KeyBuilder {
 
   protected readonly prefix: string;
 

package/src/storages/KeyBuilderCS.ts

@@ -1,7 +1,7 @@
 import { startsWith } from '../utils/lang';
-import KeyBuilder from './KeyBuilder';
+import { KeyBuilder } from './KeyBuilder';
 
-export default class KeyBuilderCS extends KeyBuilder {
+export class KeyBuilderCS extends KeyBuilder {
 
   protected readonly regexSplitsCacheKey: RegExp;
   protected readonly matchingKey: string;

package/src/storages/KeyBuilderSS.ts

@@ -1,11 +1,11 @@
-import KeyBuilder from './KeyBuilder';
+import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
 
 // NOT USED
 // const everythingAfterCount = /count\.([^/]+)$/;
 // const latencyMetricNameAndBucket = /latency\.([^/]+)\.bucket\.([0-9]+)$/;
 
-export default class KeyBuilderSS extends KeyBuilder {
+export class KeyBuilderSS extends KeyBuilder {
 
   protected readonly metadata: IMetadata;
 

package/src/storages/findLatencyIndex.ts

@@ -1,7 +1,7 @@
 import { isNaNNumber } from '../utils/lang';
 
 // @TODO add unit tests
-export default function findLatencyIndex(latency: number, min = 0, max = 23, base = 1.5): number {
+export function findLatencyIndex(latency: number, min = 0, max = 23, base = 1.5): number {
   const index = Math.min(max, Math.max(min, Math.floor(Math.log(latency) / Math.log(base))));
   return isNaNNumber(index) ? 0 : index; // index is NaN if latency is not a positive number
 }

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -1,9 +1,9 @@
 import { ILogger } from '../../logger/types';
-import AbstractSegmentsCacheSync from '../AbstractSegmentsCacheSync';
-import KeyBuilderCS from '../KeyBuilderCS';
+import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
 
-export default class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
+export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -1,14 +1,14 @@
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
-import AbstractSplitsCacheSync, { usesSegments } from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
-import KeyBuilderCS from '../KeyBuilderCS';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
-export default class SplitsCacheInLocal extends AbstractSplitsCacheSync {
+export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly splitFiltersValidation: ISplitFiltersValidation;

package/src/storages/inLocalStorage/index.ts

@@ -1,14 +1,14 @@
-import ImpressionsCacheInMemory from '../inMemory/ImpressionsCacheInMemory';
-import ImpressionCountsCacheInMemory from '../inMemory/ImpressionCountsCacheInMemory';
-import EventsCacheInMemory from '../inMemory/EventsCacheInMemory';
+import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { IStorageFactoryParams, IStorageSync, IStorageSyncFactory } from '../types';
 import { validatePrefix } from '../KeyBuilder';
-import KeyBuilderCS from '../KeyBuilderCS';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
-import SplitsCacheInLocal from './SplitsCacheInLocal';
-import MySegmentsCacheInLocal from './MySegmentsCacheInLocal';
-import MySegmentsCacheInMemory from '../inMemory/MySegmentsCacheInMemory';
-import SplitsCacheInMemory from '../inMemory/SplitsCacheInMemory';
+import { SplitsCacheInLocal } from './SplitsCacheInLocal';
+import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
+import { MySegmentsCacheInMemory } from '../inMemory/MySegmentsCacheInMemory';
+import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';

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/storages/inMemory/CountsCacheInMemory.ts

@@ -1,6 +1,6 @@
 import { ICountsCacheSync } from '../types';
 
-export default class CountsCacheInMemory implements ICountsCacheSync {
+export class CountsCacheInMemory implements ICountsCacheSync {
 
   private counters: Record<string, number> = {};
 

package/src/storages/inMemory/EventsCacheInMemory.ts

@@ -3,7 +3,7 @@ import { IEventsCacheSync } from '../types';
 
 const MAX_QUEUE_BYTE_SIZE = 5 * 1024 * 1024; // 5M
 
-export default class EventsCacheInMemory implements IEventsCacheSync {
+export class EventsCacheInMemory implements IEventsCacheSync {
 
   private onFullQueue?: () => void;
   private readonly maxQueue: number;

package/src/storages/inMemory/ImpressionCountsCacheInMemory.ts

@@ -1,7 +1,7 @@
 import { truncateTimeFrame } from '../../utils/time';
 import { IImpressionCountsCacheSync } from '../types';
 
-export default class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
+export class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
   private cache: Record<string, number> = {};
 
   /**

package/src/storages/inMemory/ImpressionsCacheInMemory.ts

@@ -1,7 +1,7 @@
 import { IImpressionsCacheSync } from '../types';
 import { ImpressionDTO } from '../../types';
 
-export default class ImpressionsCacheInMemory implements IImpressionsCacheSync {
+export class ImpressionsCacheInMemory implements IImpressionsCacheSync {
 
   private queue: ImpressionDTO[] = [];
 

package/src/storages/inMemory/InMemoryStorage.ts

@@ -1,9 +1,9 @@
-import SplitsCacheInMemory from './SplitsCacheInMemory';
-import SegmentsCacheInMemory from './SegmentsCacheInMemory';
-import ImpressionsCacheInMemory from './ImpressionsCacheInMemory';
-import EventsCacheInMemory from './EventsCacheInMemory';
+import { SplitsCacheInMemory } from './SplitsCacheInMemory';
+import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
+import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
+import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageFactoryParams, IStorageSync } from '../types';
-import ImpressionCountsCacheInMemory from './ImpressionCountsCacheInMemory';
+import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { STORAGE_MEMORY } from '../../utils/constants';
 
 /**