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

package/esm/trackers/uniqueKeysTracker.js

@@ -10,11 +10,15 @@ var noopFilterAdapter = {
  *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
  *
  * @param log Logger instance
- * @param filterAdapter filter adapter
  * @param uniqueKeysCache cache to save unique keys
+ * @param filterAdapter filter adapter
  */
 export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
+    var intervalId;
+    if (filterAdapter.refreshRate) {
+        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+    }
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
@@ -22,6 +26,9 @@ export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
                 return;
             }
             uniqueKeysCache.track(key, featureName);
+        },
+        stop: function () {
+            clearInterval(intervalId);
         }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.6.2-rc.5",
+  "version": "1.6.2-rc.8",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/evaluator/index.ts

@@ -68,28 +68,28 @@ export function evaluateFeatures(
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
 ): MaybeThenable<Record<string, IEvaluationResult>> {
-  let stringifiedSplits;
+  let parsedSplits;
 
   try {
-    stringifiedSplits = storage.splits.getSplits(splitNames);
+    parsedSplits = storage.splits.getSplits(splitNames);
   } catch (e) {
     // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
     return treatmentsException(splitNames);
   }
 
-  return (thenable(stringifiedSplits)) ?
-    stringifiedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
+  return thenable(parsedSplits) ?
+    parsedSplits.then(splits => getEvaluations(log, splitNames, splits, key, attributes, storage))
       .catch(() => {
         // Exception on async `getSplits` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         return treatmentsException(splitNames);
       }) :
-    getEvaluations(log, splitNames, stringifiedSplits, key, attributes, storage);
+    getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
 }
 
 function getEvaluation(
   log: ILogger,
-  stringifiedSplit: string | null,
+  splitJSON: ISplit | null,
   key: SplitIO.SplitKey,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,
@@ -100,8 +100,7 @@ function getEvaluation(
     config: null
   };
 
-  if (stringifiedSplit) {
-    const splitJSON: ISplit = JSON.parse(stringifiedSplit);
+  if (splitJSON) {
     const split = Engine.parse(log, splitJSON, storage);
     evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
@@ -125,7 +124,7 @@ function getEvaluation(
 function getEvaluations(
   log: ILogger,
   splitNames: string[],
-  splits: Record<string, string | null>,
+  splits: Record<string, ISplit | null>,
   key: SplitIO.SplitKey,
   attributes: SplitIO.Attributes | undefined,
   storage: IStorageSync | IStorageAsync,

package/src/integrations/ga/GaToSplit.ts

@@ -12,6 +12,7 @@ import { SplitIO } from '../../types';
 import { Identity, GoogleAnalyticsToSplitOptions } from './types';
 import { ILogger } from '../../logger/types';
 import { IIntegrationFactoryParams } from '../types';
+import { ITelemetryTracker } from '../../trackers/types';
 
 const logPrefix = 'ga-to-split: ';
 const logNameMapper = 'ga-to-split:mapper';
@@ -25,7 +26,7 @@ const logNameMapper = 'ga-to-split:mapper';
  * @param log Logger instance.
  * @param autoRequire If true, log error when auto-require script is not detected
  */
-function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire?: boolean) {
+function providePlugin(window: any, pluginName: string, pluginConstructor: Function, log: ILogger, autoRequire: boolean, telemetryTracker?: ITelemetryTracker) {
   // get reference to global command queue. Init it if not defined yet.
   const gaAlias = window.GoogleAnalyticsObject || 'ga';
   window[gaAlias] = window[gaAlias] || function () {
@@ -35,10 +36,13 @@ function providePlugin(window: any, pluginName: string, pluginConstructor: Funct
   // provides the plugin for use with analytics.js.
   window[gaAlias]('provide', pluginName, pluginConstructor);
 
-  if (autoRequire && (!window[gaAlias].q || window[gaAlias].q.push === [].push)) {
-    // Expecting spy on ga.q push method but not found
+  const hasAutoRequire = window[gaAlias].q && window[gaAlias].q.push !== [].push;
+  if (autoRequire && !hasAutoRequire) { // Expecting spy on ga.q push method but not found
     log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run. Please check the docs.');
   }
+  if (telemetryTracker && hasAutoRequire) {
+    telemetryTracker.addTag('integration:ga-autorequire');
+  }
 }
 
 // Default mapping: object used for building the default mapper from hits to Split events
@@ -191,7 +195,7 @@ export function fixEventTypeId(log: ILogger, eventTypeId: any) {
  */
 export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIntegrationFactoryParams) {
 
-  const { storage, settings: { core: coreSettings, log } } = params;
+  const { storage, settings: { core: coreSettings, log }, telemetryTracker } = params;
 
   const defaultOptions = {
     prefix: defaultPrefix,
@@ -291,5 +295,5 @@ export function GaToSplit(sdkOptions: GoogleAnalyticsToSplitOptions, params: IIn
   }
 
   // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
-  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true);
+  providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire === true, telemetryTracker);
 }

package/src/integrations/types.ts

@@ -1,5 +1,5 @@
 import { IEventsCacheBase } from '../storages/types';
-import { IEventsHandler, IImpressionsHandler } from '../trackers/types';
+import { IEventsHandler, IImpressionsHandler, ITelemetryTracker } from '../trackers/types';
 import { ISettings, SplitIO } from '../types';
 
 export interface IIntegration {
@@ -11,6 +11,7 @@ export type IIntegrationManager = IEventsHandler & IImpressionsHandler;
 export interface IIntegrationFactoryParams {
   storage: { events: IEventsCacheBase }
   settings: ISettings
+  telemetryTracker: ITelemetryTracker
 }
 
 export type IntegrationFactory = {

package/src/sdkClient/sdkClient.ts

@@ -9,7 +9,7 @@ import { ISdkFactoryContext } from '../sdkFactory/types';
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
 export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
-  const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker } = params;
+  const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker, uniqueKeysTracker } = params;
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
@@ -39,6 +39,8 @@ 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
           return storage.destroy();

package/src/sdkFactory/index.ts

@@ -68,7 +68,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const storage = storageFactory(storageFactoryParams);
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
 
-  const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, 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;
@@ -87,7 +88,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
   const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
-  const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);

package/src/sdkManager/index.ts

@@ -18,16 +18,7 @@ function collectTreatments(splitObject: ISplit) {
   return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(v => v.treatment) : [];
 }
 
-function objectToView(json: string | null): SplitIO.SplitView | null {
-  let splitObject: ISplit | null;
-
-  try {
-    // @ts-expect-error
-    splitObject = JSON.parse(json);
-  } catch (e) {
-    return null;
-  }
-
+function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
   if (!splitObject) return null;
 
   return {
@@ -40,10 +31,10 @@ function objectToView(json: string | null): SplitIO.SplitView | null {
   };
 }
 
-function objectsToViews(jsons: string[]) {
+function objectsToViews(splitObjects: ISplit[]) {
   let views: SplitIO.SplitView[] = [];
 
-  jsons.forEach(split => {
+  splitObjects.forEach(split => {
     const view = objectToView(split);
     if (view) views.push(view);
   });

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -1,5 +1,6 @@
 import { ISplitsCacheAsync } from './types';
 import { ISplit } from '../dtos/types';
+import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheAsync interface
@@ -7,14 +8,14 @@ import { ISplit } from '../dtos/types';
  */
 export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
 
-  abstract addSplit(name: string, split: string): Promise<boolean>
-  abstract addSplits(entries: [string, string][]): Promise<boolean[] | void>
+  abstract addSplit(name: string, split: ISplit): Promise<boolean>
+  abstract addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>
   abstract removeSplits(names: string[]): Promise<boolean[] | void>
-  abstract getSplit(name: string): Promise<string | null>
-  abstract getSplits(names: string[]): Promise<Record<string, string | null>>
+  abstract getSplit(name: string): Promise<ISplit | null>
+  abstract getSplits(names: string[]): Promise<Record<string, ISplit | null>>
   abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
   abstract getChangeNumber(): Promise<number>
-  abstract getAll(): Promise<string[]>
+  abstract getAll(): Promise<ISplit[]>
   abstract getSplitNames(): Promise<string[]>
   abstract trafficTypeExists(trafficType: string): Promise<boolean>
   abstract clear(): Promise<boolean | void>
@@ -47,16 +48,13 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean> {
     return this.getSplit(name).then(split => {
 
-      if (split) {
-        const parsedSplit: ISplit = JSON.parse(split);
-        if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-          parsedSplit.killed = true;
-          parsedSplit.defaultTreatment = defaultTreatment;
-          parsedSplit.changeNumber = changeNumber;
-          const newSplit = JSON.stringify(parsedSplit);
+      if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+        const newSplit = objectAssign({}, split);
+        newSplit.killed = true;
+        newSplit.defaultTreatment = defaultTreatment;
+        newSplit.changeNumber = changeNumber;
 
-          return this.addSplit(name, newSplit);
-        }
+        return this.addSplit(name, newSplit);
       }
       return false;
     }).catch(() => false);

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,5 +1,6 @@
 import { ISplitsCacheSync } from './types';
 import { ISplit } from '../dtos/types';
+import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
@@ -7,9 +8,9 @@ import { ISplit } from '../dtos/types';
  */
 export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
-  abstract addSplit(name: string, split: string): boolean;
+  abstract addSplit(name: string, split: ISplit): boolean
 
-  addSplits(entries: [string, string][]): boolean[] {
+  addSplits(entries: [string, ISplit][]): boolean[] {
     return entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1]));
   }
 
@@ -19,10 +20,10 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return names.map(name => this.removeSplit(name));
   }
 
-  abstract getSplit(name: string): string | null
+  abstract getSplit(name: string): ISplit | null
 
-  getSplits(names: string[]): Record<string, string | null> {
-    const splits: Record<string, string | null> = {};
+  getSplits(names: string[]): Record<string, ISplit | null> {
+    const splits: Record<string, ISplit | null> = {};
     names.forEach(name => {
       splits[name] = this.getSplit(name);
     });
@@ -33,8 +34,8 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   abstract getChangeNumber(): number
 
-  getAll(): string[] {
-    return this.getSplitNames().map(key => this.getSplit(key) as string);
+  getAll(): ISplit[] {
+    return this.getSplitNames().map(key => this.getSplit(key) as ISplit);
   }
 
   abstract getSplitNames(): string[]
@@ -66,16 +67,13 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean {
     const split = this.getSplit(name);
 
-    if (split) {
-      const parsedSplit: ISplit = JSON.parse(split);
-      if (!parsedSplit.changeNumber || parsedSplit.changeNumber < changeNumber) {
-        parsedSplit.killed = true;
-        parsedSplit.defaultTreatment = defaultTreatment;
-        parsedSplit.changeNumber = changeNumber;
-        const newSplit = JSON.stringify(parsedSplit);
+    if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+      const newSplit = objectAssign({}, split);
+      newSplit.killed = true;
+      newSplit.defaultTreatment = defaultTreatment;
+      newSplit.changeNumber = changeNumber;
 
-        return this.addSplit(name, newSplit);
-      }
+      return this.addSplit(name, newSplit);
     }
     return false;
   }

package/src/storages/dataLoader.ts

@@ -39,7 +39,7 @@ export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoa
     storage.splits.setChangeNumber(since);
 
     // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.addSplits(Object.keys(splitsData).map(splitName => [splitName, splitsData[splitName]]));
+    storage.splits.addSplits(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])));
 
     // add mySegments data
     let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -38,7 +38,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     else localStorage.removeItem(key);
   }
 
-  private _decrementCounts(split: ISplit) {
+  private _decrementCounts(split: ISplit | null) {
     try {
       if (split) {
         if (split.trafficTypeName) {
@@ -99,18 +99,16 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     this.hasSync = false;
   }
 
-  addSplit(name: string, split: string) {
+  addSplit(name: string, split: ISplit) {
     try {
       const splitKey = this.keys.buildSplitKey(name);
       const splitFromLocalStorage = localStorage.getItem(splitKey);
       const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
       this._decrementCounts(previousSplit);
 
-      localStorage.setItem(splitKey, split);
+      localStorage.setItem(splitKey, JSON.stringify(split));
 
-      const parsedSplit = split ? JSON.parse(split) : null;
-
-      this._incrementCounts(parsedSplit);
+      this._incrementCounts(split);
 
       return true;
     } catch (e) {
@@ -124,8 +122,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       const split = this.getSplit(name);
       localStorage.removeItem(this.keys.buildSplitKey(name));
 
-      const parsedSplit = JSON.parse(split as string);
-      this._decrementCounts(parsedSplit);
+      this._decrementCounts(split);
 
       return true;
     } catch (e) {
@@ -135,7 +132,8 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   getSplit(name: string) {
-    return localStorage.getItem(this.keys.buildSplitKey(name));
+    const item = localStorage.getItem(this.keys.buildSplitKey(name));
+    return item && JSON.parse(item);
   }
 
   setChangeNumber(changeNumber: number): boolean {
@@ -184,7 +182,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     return n;
   }
 
-  getSplitNames() {
+  getSplitNames(): string[] {
     const len = localStorage.length;
     const accum = [];
 

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -8,7 +8,7 @@ import { isFiniteNumber } from '../../utils/lang';
  */
 export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
-  private splitsCache: Record<string, string> = {};
+  private splitsCache: Record<string, ISplit> = {};
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
   private splitsWithSegmentsCount: number = 0;
@@ -20,10 +20,9 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.splitsWithSegmentsCount = 0;
   }
 
-  addSplit(name: string, split: string): boolean {
-    const splitFromMemory = this.getSplit(name);
-    if (splitFromMemory) { // We had this Split already
-      const previousSplit: ISplit = JSON.parse(splitFromMemory);
+  addSplit(name: string, split: ISplit): boolean {
+    const previousSplit = this.getSplit(name);
+    if (previousSplit) { // We had this Split already
 
       if (previousSplit.trafficTypeName) {
         const previousTtName = previousSplit.trafficTypeName;
@@ -36,20 +35,18 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       }
     }
 
-    const parsedSplit: ISplit = JSON.parse(split);
-
-    if (parsedSplit) {
+    if (split) {
       // Store the Split.
       this.splitsCache[name] = split;
       // Update TT cache
-      const ttName = parsedSplit.trafficTypeName;
+      const ttName = split.trafficTypeName;
       if (ttName) { // safeguard
         if (!this.ttCache[ttName]) this.ttCache[ttName] = 0;
         this.ttCache[ttName]++;
       }
 
       // Add to segments count for the new version of the Split
-      if (usesSegments(parsedSplit)) this.splitsWithSegmentsCount++;
+      if (usesSegments(split)) this.splitsWithSegmentsCount++;
 
       return true;
     } else {
@@ -63,8 +60,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       // Delete the Split
       delete this.splitsCache[name];
 
-      const parsedSplit: ISplit = JSON.parse(split);
-      const ttName = parsedSplit.trafficTypeName;
+      const ttName = split.trafficTypeName;
 
       if (ttName) { // safeguard
         this.ttCache[ttName]--; // Update tt cache
@@ -72,7 +68,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       }
 
       // Update the segments count.
-      if (usesSegments(parsedSplit)) this.splitsWithSegmentsCount--;
+      if (usesSegments(split)) this.splitsWithSegmentsCount--;
 
       return true;
     } else {
@@ -80,7 +76,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     }
   }
 
-  getSplit(name: string): string | null {
+  getSplit(name: string): ISplit | null {
     return this.splitsCache[name] || null;
   }
 

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -8,19 +8,22 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
   private readonly log: ILogger;
   private readonly key: string;
   private readonly redis: Redis;
-  private handle: any;
+  private readonly refreshRate: number;
+  private intervalId: any;
   
-  constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number) {
+  constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number, refreshRate: number = REFRESH_RATE) {
     super(impressionCountsCacheSize);
     this.log = log;
     this.key = key;
     this.redis = redis;
+    this.refreshRate = refreshRate;
     this.onFullQueue = () => { this.postImpressionCountsInRedis(); };
   }
   
   postImpressionCountsInRedis(){
     const counts = this.pop();
     const keys = Object.keys(counts);
+    if (!keys) return Promise.resolve(false);
     const pipeline = this.redis.pipeline();
     keys.forEach(key => {
       pipeline.hincrby(this.key, key, counts[key]);
@@ -34,15 +37,16 @@ export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory
       })
       .catch(err => {
         this.log.error(`${LOG_PREFIX}Error in impression counts pipeline: ${err}.`);
-        return false;
+        return Promise.resolve(false);
       });
   }
   
-  start(refreshRate: number = REFRESH_RATE) {
-    this.handle = setInterval(this.postImpressionCountsInRedis.bind(this), refreshRate);
+  start() {
+    this.intervalId = setInterval(this.postImpressionCountsInRedis.bind(this), this.refreshRate);
   }
   
   stop() {
-    clearInterval(this.handle);
+    clearInterval(this.intervalId);
+    return this.postImpressionCountsInRedis();
   }
 }

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -65,22 +65,22 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., redis operation fails)
    */
-  addSplit(name: string, split: string): Promise<boolean> {
+  addSplit(name: string, split: ISplit): Promise<boolean> {
     const splitKey = this.keys.buildSplitKey(name);
     return this.redis.get(splitKey).then(splitFromStorage => {
 
       // handling parsing errors
-      let parsedPreviousSplit, parsedSplit;
+      let parsedPreviousSplit, newStringifiedSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        parsedSplit = JSON.parse(split);
+        newStringifiedSplit = JSON.stringify(split);
       } catch (e) {
         throw new Error('Error parsing split definition: ' + e);
       }
 
       return Promise.all([
-        this.redis.set(splitKey, split),
-        this._incrementCounts(parsedSplit),
+        this.redis.set(splitKey, newStringifiedSplit),
+        this._incrementCounts(split),
         // If it's an update, we decrement the traffic type of the existing split,
         parsedPreviousSplit && this._decrementCounts(parsedPreviousSplit)
       ]);
@@ -92,7 +92,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., redis operation fails)
    */
-  addSplits(entries: [string, string][]): Promise<boolean[]> {
+  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
     return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
   }
 
@@ -104,8 +104,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   removeSplit(name: string): Promise<number> {
     return this.getSplit(name).then((split) => {
       if (split) {
-        const parsedSplit = JSON.parse(split);
-        this._decrementCounts(parsedSplit);
+        this._decrementCounts(split);
       }
       return this.redis.del(this.keys.buildSplitKey(name));
     });
@@ -124,14 +123,15 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * Get split definition or null if it's not defined.
    * Returned promise is rejected if redis operation fails.
    */
-  getSplit(name: string): Promise<string | null> {
+  getSplit(name: string): Promise<ISplit | null> {
     if (this.redisError) {
       this.log.error(LOG_PREFIX + this.redisError);
 
       return Promise.reject(this.redisError);
     }
 
-    return this.redis.get(this.keys.buildSplitKey(name));
+    return this.redis.get(this.keys.buildSplitKey(name))
+      .then(maybeSplit => maybeSplit && JSON.parse(maybeSplit));
   }
 
   /**
@@ -169,10 +169,13 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * @TODO we need to benchmark which is the maximun number of commands we could
    *       pipeline without kill redis performance.
    */
-  getAll(): Promise<string[]> {
-    return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(
-      (listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec()
-    ).then(processPipelineAnswer);
+  getAll(): Promise<ISplit[]> {
+    return this.redis.keys(this.keys.searchPatternForSplitKeys())
+      .then((listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec())
+      .then(processPipelineAnswer)
+      .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
+        return JSON.parse(splitDefinition as string);
+      }));
   }
 
   /**
@@ -226,19 +229,20 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * Fetches multiple splits definitions.
    * Returned promise is rejected if redis operation fails.
    */
-  getSplits(names: string[]): Promise<Record<string, string | null>> {
+  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
     if (this.redisError) {
       this.log.error(LOG_PREFIX + this.redisError);
 
       return Promise.reject(this.redisError);
     }
 
-    const splits: Record<string, string | null> = {};
+    const splits: Record<string, ISplit | null> = {};
     const keys = names.map(name => this.keys.buildSplitKey(name));
     return this.redis.mget(...keys)
       .then(splitDefinitions => {
         names.forEach((name, idx) => {
-          splits[name] = splitDefinitions[idx];
+          const split = splitDefinitions[idx];
+          splits[name] = split && JSON.parse(split);
         });
         return Promise.resolve(splits);
       })

package/src/storages/inRedis/index.ts

@@ -52,10 +52,11 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
       // When using REDIS we should:
       // 1- Disconnect from the storage
-      destroy() {
-        redisClient.disconnect();
-        if (impressionCountsCache) impressionCountsCache.stop();
-        if (uniqueKeysCache) uniqueKeysCache.stop();
+      destroy(): Promise<void>{
+        let promises = [];
+        if (impressionCountsCache) promises.push(impressionCountsCache.stop());
+        if (uniqueKeysCache) promises.push(uniqueKeysCache.stop());
+        return Promise.all(promises).then(() => { redisClient.disconnect(); });
         // @TODO check that caches works as expected when redisClient is disconnected
       }
     };