@splitsoftware/splitio-commons 1.6.2-rc.8 → 1.7.0

package/esm/utils/lang/maps.js

@@ -37,13 +37,6 @@ var MapPoly = /** @class */ (function () {
         this.__mapKeysData__.length = 0;
         this.__mapValuesData__.length = 0;
     };
-    MapPoly.prototype.set = function (key, value) {
-        var index = this.__mapKeysData__.indexOf(key);
-        if (index === -1)
-            index = this.__mapKeysData__.push(key) - 1;
-        this.__mapValuesData__[index] = value;
-        return this;
-    };
     MapPoly.prototype.delete = function (key) {
         var index = this.__mapKeysData__.indexOf(key);
         if (index === -1)
@@ -52,12 +45,27 @@ var MapPoly = /** @class */ (function () {
         this.__mapValuesData__.splice(index, 1);
         return true;
     };
+    MapPoly.prototype.forEach = function (callbackfn, thisArg) {
+        for (var i = 0; i < this.__mapKeysData__.length; i++) {
+            callbackfn.call(thisArg, this.__mapValuesData__[i], this.__mapKeysData__[i], this);
+        }
+    };
     MapPoly.prototype.get = function (key) {
         var index = this.__mapKeysData__.indexOf(key);
         if (index === -1)
             return;
         return this.__mapValuesData__[index];
     };
+    MapPoly.prototype.has = function (key) {
+        return this.__mapKeysData__.indexOf(key) !== -1;
+    };
+    MapPoly.prototype.set = function (key, value) {
+        var index = this.__mapKeysData__.indexOf(key);
+        if (index === -1)
+            index = this.__mapKeysData__.push(key) - 1;
+        this.__mapValuesData__[index] = value;
+        return this;
+    };
     Object.defineProperty(MapPoly.prototype, "size", {
         get: function () {
             return this.__mapKeysData__.length;

package/esm/utils/redis/RedisMock.js

@@ -0,0 +1,28 @@
+//@ts-nocheck
+function identityFunction(data) {
+    return data;
+}
+function asyncFunction(data) {
+    return Promise.resolve(data);
+}
+var IDENTITY_METHODS = [];
+var ASYNC_METHODS = ['rpush', 'hincrby'];
+var PIPELINE_METHODS = ['rpush', 'hincrby'];
+var RedisMock = /** @class */ (function () {
+    function RedisMock() {
+        var _this = this;
+        this.pipelineMethods = { exec: jest.fn(asyncFunction) };
+        IDENTITY_METHODS.forEach(function (method) {
+            _this[method] = jest.fn(identityFunction);
+        });
+        ASYNC_METHODS.forEach(function (method) {
+            _this[method] = jest.fn(asyncFunction);
+        });
+        PIPELINE_METHODS.forEach(function (method) {
+            _this.pipelineMethods[method] = _this[method];
+        });
+        this.pipeline = jest.fn(function () { return _this.pipelineMethods; });
+    }
+    return RedisMock;
+}());
+export { RedisMock };

package/esm/utils/settingsValidation/index.js

@@ -31,8 +31,6 @@ export var base = {
         telemetryRefreshRate: 3600,
         // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
         impressionsRefreshRate: 300,
-        // publish unique Keys each 900 sec (15 min) 
-        uniqueKeysRefreshRate: 900,
         // fetch offline changes each 15 sec
         offlineRefreshRate: 15,
         // publish events every 60 seconds after the first flush
@@ -111,7 +109,6 @@ export function settingsValidation(config, validationParams) {
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-    scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
     // Default impressionsRefreshRate for DEBUG mode is 60 secs
     if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG)
@@ -132,8 +129,8 @@ export function settingsValidation(config, validationParams) {
     if (storage)
         withDefaults.storage = storage(withDefaults);
     // Validate key and TT (for client-side)
+    var maybeKey = withDefaults.core.key;
     if (validationParams.acceptKey) {
-        var maybeKey = withDefaults.core.key;
         // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
         if (withDefaults.mode === LOCALHOST_MODE && maybeKey === undefined) {
             withDefaults.core.key = 'localhost_key';
@@ -151,6 +148,12 @@ export function settingsValidation(config, validationParams) {
             }
         }
     }
+    else {
+        // On server-side, key is undefined and used to distinguish from client-side
+        if (maybeKey !== undefined)
+            log.warn('Provided `key` is ignored in server-side SDK.'); // @ts-ignore
+        withDefaults.core.key = undefined;
+    }
     // Current ip/hostname information
     // @ts-ignore, modify readonly prop
     withDefaults.runtime = runtime(withDefaults);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.8",
+  "version": "1.7.0",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -24,6 +24,7 @@
     "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
     "test": "jest",
     "test:coverage": "jest --coverage",
+    "all": "npm run check && npm run build && npm run test",
     "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",
     "publish:stable": "npm run check && npm run test && npm run build && npm publish"
   },
@@ -70,7 +71,6 @@
     "ioredis": "^4.28.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
-    "js-yaml": "^3.13.1",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.7",
     "redis-server": "1.2.2",

package/src/consent/sdkUserConsent.ts

@@ -40,7 +40,7 @@ export function createUserConsentAPI(params: ISdkFactoryContext) {
 
           // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
           if (events.clear) events.clear(); // @ts-ignore
-          if (impressions.clear) impressions.clear();// @ts-ignore
+          if (impressions.clear) impressions.clear(); // @ts-ignore
           if (impressionCounts && impressionCounts.clear) impressionCounts.clear();
         }
       } else {

package/src/evaluator/index.ts

@@ -29,19 +29,19 @@ export function evaluateFeature(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<IEvaluationResult> {
-  let stringifiedSplit;
+  let parsedSplit;
 
   try {
-    stringifiedSplit = storage.splits.getSplit(splitName);
+    parsedSplit = storage.splits.getSplit(splitName);
   } catch (e) {
     // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
     return treatmentException;
   }
 
-  if (thenable(stringifiedSplit)) {
-    return stringifiedSplit.then((result) => getEvaluation(
+  if (thenable(parsedSplit)) {
+    return parsedSplit.then((split) => getEvaluation(
       log,
-      result,
+      split,
       key,
       attributes,
       storage,
@@ -54,7 +54,7 @@ export function evaluateFeature(
 
   return getEvaluation(
     log,
-    stringifiedSplit,
+    parsedSplit,
     key,
     attributes,
     storage,

package/src/listeners/browser.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-undef */
 // @TODO eventually migrate to JS-Browser-SDK package.
 import { ISignalListener } from './types';
-import { IRecorderCacheProducerSync, IStorageSync } from '../storages/types';
+import { IRecorderCacheSync, IStorageSync } from '../storages/types';
 import { fromImpressionsCollector } from '../sync/submitters/impressionsSubmitter';
 import { fromImpressionCountsCollector } from '../sync/submitters/impressionCountsSubmitter';
 import { IResponse, ISplitApi } from '../services/types';
@@ -12,7 +12,6 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
 import { isConsentGranted } from '../consent';
-import { telemetryCacheStatsAdapter } from '../sync/submitters/telemetrySubmitter';
 
 const VISIBILITYCHANGE_EVENT = 'visibilitychange';
 const PAGEHIDE_EVENT = 'pagehide';
@@ -84,27 +83,25 @@ export class BrowserSignalListener implements ISignalListener {
    */
   flushData() {
     if (!this.syncManager) return; // In consumer mode there is not sync manager and data to flush
+    const { events, telemetry } = this.settings.urls;
 
     // Flush impressions & events data if there is user consent
     if (isConsentGranted(this.settings)) {
-      const eventsUrl = this.settings.urls.events;
       const sim = this.settings.sync.impressionsMode;
       const extraMetadata = {
         // sim stands for Sync/Split Impressions Mode
         sim: sim === OPTIMIZED ? OPTIMIZED : sim === DEBUG ? DEBUG : NONE
       };
 
-      this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
-      this._flushData(eventsUrl + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
-      if (this.storage.impressionCounts) this._flushData(eventsUrl + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);
+      this._flushData(events + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
+      this._flushData(events + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
+      if (this.storage.impressionCounts) this._flushData(events + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);
+      // @ts-ignore
+      if (this.storage.uniqueKeys) this._flushData(telemetry + '/v1/keys/cs/beacon', this.storage.uniqueKeys, this.serviceApi.postUniqueKeysBulkCs);
     }
 
     // Flush telemetry data
-    if (this.storage.telemetry) {
-      const telemetryUrl = this.settings.urls.telemetry;
-      const telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
-      this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
-    }
+    if (this.storage.telemetry) this._flushData(telemetry + '/v1/metrics/usage/beacon', this.storage.telemetry, this.serviceApi.postMetricsUsage);
   }
 
   flushDataIfHidden() {
@@ -112,14 +109,13 @@ export class BrowserSignalListener implements ISignalListener {
     if (document.visibilityState === 'hidden') this.flushData(); // On a 'visibilitychange' event, flush data if state is hidden
   }
 
-  private _flushData<T>(url: string, cache: IRecorderCacheProducerSync<T>, postService: (body: string) => Promise<IResponse>, fromCacheToPayload?: (cacheData: T) => any, extraMetadata?: {}) {
+  private _flushData<T>(url: string, cache: IRecorderCacheSync<T>, postService: (body: string) => Promise<IResponse>, fromCacheToPayload?: (cacheData: T) => any, extraMetadata?: {}) {
     // if there is data in cache, send it to backend
     if (!cache.isEmpty()) {
       const dataPayload = fromCacheToPayload ? fromCacheToPayload(cache.pop()) : cache.pop();
       if (!this._sendBeacon(url, dataPayload, extraMetadata)) {
         postService(JSON.stringify(dataPayload)).catch(() => { }); // no-op just to catch a possible exception
       }
-      cache.clear();
     }
   }
 

package/src/sdkClient/client.ts

@@ -9,6 +9,17 @@ import { IEvaluationResult } from '../evaluator/types';
 import { SplitIO, ImpressionDTO } from '../types';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
+import { isStorageSync } from '../trackers/impressionObserver/utils';
+
+const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
+
+function treatmentsNotReady(splitNames: string[]) {
+  const evaluations: Record<string, IEvaluationResult> = {};
+  splitNames.forEach(splitName => {
+    evaluations[splitName] = treatmentNotReady;
+  });
+  return evaluations;
+}
 
 /**
  * Creator of base client with getTreatments and track methods.
@@ -29,7 +40,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatment;
     };
 
-    const evaluation = evaluateFeature(log, key, splitName, attributes, storage);
+    const evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+      evaluateFeature(log, key, splitName, attributes, storage) :
+      isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+        treatmentNotReady :
+        Promise.resolve(treatmentNotReady); // Promisify if async
 
     return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
   }
@@ -53,7 +68,11 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
       return treatments;
     };
 
-    const evaluations = evaluateFeatures(log, key, splitNames, attributes, storage);
+    const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+      evaluateFeatures(log, key, splitNames, attributes, storage) :
+      isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+        treatmentsNotReady(splitNames) :
+        Promise.resolve(treatmentsNotReady(splitNames)); // Promisify if async
 
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }
@@ -72,15 +91,9 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     invokingMethodName: string,
     queue: ImpressionDTO[]
   ): SplitIO.Treatment | SplitIO.TreatmentWithConfig {
-    const isSdkReady = readinessManager.isReady() || readinessManager.isReadyFromCache();
     const matchingKey = getMatching(key);
     const bucketingKey = getBucketing(key);
 
-    // If the SDK was not ready, treatment may be incorrect due to having Splits but not segments data.
-    if (!isSdkReady) {
-      evaluation = { treatment: CONTROL, label: SDK_NOT_READY };
-    }
-
     const { treatment, label, changeNumber, config = null } = evaluation;
     log.info(IMPRESSION, [splitName, matchingKey, treatment, label]);
 

package/src/sdkClient/sdkClient.ts

@@ -39,7 +39,7 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
 
           // Release the API Key if it is the main client
           if (!isSharedClient) releaseApiKey(settings.core.authorizationKey);
-          
+
           if (uniqueKeysTracker) uniqueKeysTracker.stop();
 
           // Cleanup storage

package/src/sdkFactory/index.ts

@@ -3,14 +3,10 @@ import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
 import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import { IStorageFactoryParams } from '../storages/types';
 import { SplitIO } from '../types';
-import { getMatching } from '../utils/key';
-import { shouldBeOptimized } from '../trackers/impressionObserver/utils';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { metadataBuilder } from '../storages/metadataBuilder';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
@@ -28,7 +24,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
     filterAdapterFactory } = params;
-  const log = settings.log;
+  const { log, sync: { impressionsMode } } = settings;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid API Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
@@ -39,50 +35,31 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
   const readiness = sdkReadinessManager.readinessManager;
 
-  // @TODO consider passing the settings object, so that each storage access only what it needs
-  const storageFactoryParams: IStorageFactoryParams = {
-    impressionsQueueSize: settings.scheduler.impressionsQueueSize,
-    eventsQueueSize: settings.scheduler.eventsQueueSize,
-    uniqueKeysCacheSize: settings.scheduler.uniqueKeysCacheSize,
-    optimize: shouldBeOptimized(settings),
-
-    // ATM, only used by InLocalStorage
-    matchingKey: getMatching(settings.core.key),
-    splitFiltersValidation: settings.sync.__splitFiltersValidation,
-
-    // ATM, only used by PluggableStorage
-    mode: settings.mode,
-    impressionsMode: settings.sync.impressionsMode,
-
-    // 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.
+  const storage = storageFactory({
+    settings,
     onReadyCb: (error) => {
       if (error) return; // Don't emit SDK_READY if storage failed to connect. Error message is logged by wrapperAdapter
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
-    metadata: metadataBuilder(settings),
-    log
-  };
-
-  const storage = storageFactory(storageFactoryParams);
+  });
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
 
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
   const observer = impressionsObserverFactory();
-  const uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
+  const uniqueKeysTracker = impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
 
   let strategy;
-  switch (storageFactoryParams.impressionsMode) {
-    case OPTIMIZED: 
+  switch (impressionsMode) {
+    case OPTIMIZED:
       strategy = strategyOptimizedFactory(observer, storage.impressionCounts!);
       break;
-    case NONE: 
+    case NONE:
       strategy = strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!);
       break;
-    default: 
+    default:
       strategy = strategyDebugFactory(observer);
   }
 
@@ -121,7 +98,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     },
 
     // Logger wrapper API
-    Logger: createLoggerAPI(settings.log),
+    Logger: createLoggerAPI(log),
 
     settings,
   }, extraProps && extraProps(ctx));

package/src/sdkFactory/types.ts

@@ -97,9 +97,9 @@ export interface ISdkFactoryParams {
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).
   sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
 
-  // Impression observer factory. If provided, will be used for impressions dedupe
+  // Impression observer factory.
   impressionsObserverFactory: () => IImpressionObserver
-  
+
   filterAdapterFactory?: () => IFilterAdapter
 
   // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.

package/src/services/splitApi.ts

@@ -106,7 +106,7 @@ export function splitApiFactory(
       const url = `${urls.events}/testImpressions/count`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
     },
-    
+
     /**
      * Post unique keys for client side.
      *
@@ -117,7 +117,7 @@ export function splitApiFactory(
       const url = `${urls.telemetry}/v1/keys/cs`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
     },
-    
+
     /**
      * Post unique keys for server side.
      *
@@ -129,14 +129,14 @@ export function splitApiFactory(
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
     },
 
-    postMetricsConfig(body: string) {
+    postMetricsConfig(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/v1/metrics/config`;
-      return splitHttpClient(url, { method: 'POST', body }, telemetryTracker.trackHttp(TELEMETRY), true);
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
     },
 
-    postMetricsUsage(body: string) {
+    postMetricsUsage(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/v1/metrics/usage`;
-      return splitHttpClient(url, { method: 'POST', body }, telemetryTracker.trackHttp(TELEMETRY), true);
+      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), true);
     }
   };
 }

package/src/services/types.ts

@@ -51,9 +51,9 @@ export type IPostTestImpressionsBulk = (body: string, headers?: Record<string, s
 
 export type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
-export type IPostMetricsConfig = (body: string) => Promise<IResponse>
+export type IPostMetricsConfig = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
-export type IPostMetricsUsage = (body: string) => Promise<IResponse>
+export type IPostMetricsUsage = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
 export interface ISplitApi {
 	getSdkAPIHealthCheck: IHealthCheckAPI

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -41,7 +41,7 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
    * @param {string} name
    * @param {string} defaultTreatment
    * @param {number} changeNumber
-   * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated,
+   * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
    * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
    * The promise will never be rejected.
    */

package/src/storages/AbstractSplitsCacheSync.ts

@@ -61,7 +61,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
    * @param {string} name
    * @param {string} defaultTreatment
    * @param {number} changeNumber
-   * @returns {Promise} a promise that is resolved once the split kill is performed. The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated,
+   * @returns {boolean} `true` if the operation successed updating the split, or `false` if no split is updated,
    * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
    */
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean {

package/src/storages/KeyBuilderSS.ts

@@ -2,7 +2,7 @@ import { KeyBuilder } from './KeyBuilder';
 import { IMetadata } from '../dtos/types';
 import { Method } from '../sync/submitters/types';
 
-const methodNames: Record<Method, string> = {
+export const METHOD_NAMES: Record<Method, string> = {
   t: 'treatment',
   ts: 'treatments',
   tc: 'treatmentWithConfig',
@@ -12,11 +12,17 @@ const methodNames: Record<Method, string> = {
 
 export class KeyBuilderSS extends KeyBuilder {
 
-  protected readonly metadata: IMetadata;
+  latencyPrefix: string;
+  exceptionPrefix: string;
+  initPrefix: string;
+  private versionablePrefix: string;
 
   constructor(prefix: string, metadata: IMetadata) {
     super(prefix);
-    this.metadata = metadata;
+    this.latencyPrefix = `${this.prefix}.telemetry.latencies`;
+    this.exceptionPrefix = `${this.prefix}.telemetry.exceptions`;
+    this.initPrefix = `${this.prefix}.telemetry.init`;
+    this.versionablePrefix = `${metadata.s}/${metadata.n}/${metadata.i}`;
   }
 
   buildRegisteredSegmentsKey() {
@@ -30,7 +36,7 @@ export class KeyBuilderSS extends KeyBuilder {
   buildImpressionsCountKey() {
     return `${this.prefix}.impressions.count`;
   }
-  
+
   buildUniqueKeysKey() {
     return `${this.prefix}.uniquekeys`;
   }
@@ -46,19 +52,15 @@ export class KeyBuilderSS extends KeyBuilder {
   /* Telemetry keys */
 
   buildLatencyKey(method: Method, bucket: number) {
-    return `${this.prefix}.telemetry.latencies::${this.buildVersionablePrefix()}/${methodNames[method]}/${bucket}`;
+    return `${this.latencyPrefix}::${this.versionablePrefix}/${METHOD_NAMES[method]}/${bucket}`;
   }
 
   buildExceptionKey(method: Method) {
-    return `${this.prefix}.telemetry.exceptions::${this.buildVersionablePrefix()}/${methodNames[method]}`;
+    return `${this.exceptionPrefix}::${this.versionablePrefix}/${METHOD_NAMES[method]}`;
   }
 
   buildInitKey() {
-    return `${this.prefix}.telemetry.init::${this.buildVersionablePrefix()}`;
-  }
-
-  private buildVersionablePrefix() {
-    return `${this.metadata.s}/${this.metadata.n}/${this.metadata.i}`;
+    return `${this.initPrefix}::${this.versionablePrefix}`;
   }
 
 }

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -229,7 +229,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   /**
    * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-   * Clean operation (clear) also updates `lastUpdated` timestamp with current time.
    *
    * @param {number | undefined} expirationTimestamp if the value is not a number, data will not be cleaned
    */

package/src/storages/inLocalStorage/index.ts

@@ -12,9 +12,10 @@ 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';
-import { LOCALHOST_MODE, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from '../inMemory/uniqueKeysCacheInMemoryCS';
+import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
+import { getMatching } from '../../utils/key';
 
 export interface InLocalStorageOptions {
   prefix?: string
@@ -31,22 +32,26 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
 
     // Fallback to InMemoryStorage if LocalStorage API is not available
     if (!isLocalStorageAvailable()) {
-      params.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
+      params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
       return InMemoryStorageCSFactory(params);
     }
 
-    const log = params.log;
-    const keys = new KeyBuilderCS(prefix, params.matchingKey as string);
+    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
+    const matchingKey = getMatching(settings.core.key);
+    const keys = new KeyBuilderCS(prefix, matchingKey as string);
     const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
+    const splits = new SplitsCacheInLocal(log, keys, expirationTimestamp, __splitFiltersValidation);
+    const segments = new MySegmentsCacheInLocal(log, keys);
+
     return {
-      splits: new SplitsCacheInLocal(log, keys, expirationTimestamp, params.splitFiltersValidation),
-      segments: new MySegmentsCacheInLocal(log, keys),
-      impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-      impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
-      events: new EventsCacheInMemory(params.eventsQueueSize),
-      telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
-      uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
+      splits,
+      segments,
+      impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+      impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+      events: new EventsCacheInMemory(eventsQueueSize),
+      telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+      uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
       destroy() {
         this.splits = new SplitsCacheInMemory();