@splitsoftware/splitio-commons 1.6.2-rc.0 → 1.6.2-rc.10

package/src/storages/inMemory/UniqueKeysCacheInMemoryCS.ts

@@ -0,0 +1,88 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { ISet, setToArray, _Set } from '../../utils/lang/sets';
+import { UniqueKeysPayloadCs } from '../../sync/submitters/types';
+import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
+
+export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
+
+  private onFullQueue?: () => void;
+  private readonly maxStorage: number;
+  private uniqueTrackerSize = 0;
+  private uniqueKeysTracker: { [keys: string]: ISet<string> };
+
+  /**
+   *
+   * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+   * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+   */
+  constructor(uniqueKeysQueueSize = DEFAULT_CACHE_SIZE) {
+    this.maxStorage = uniqueKeysQueueSize;
+    this.uniqueKeysTracker = {};
+  }
+
+  setOnFullQueueCb(cb: () => void) {
+    this.onFullQueue = cb;
+  }
+
+  /**
+   * Store unique keys in sequential order
+   * key: string = key.
+   * value: HashSet<string> = set of split names.
+   */
+  track(key: string, featureName: string) {
+
+    if (!this.uniqueKeysTracker[key]) this.uniqueKeysTracker[key] = new _Set();
+    const tracker = this.uniqueKeysTracker[key];
+    if (!tracker.has(featureName)) {
+      tracker.add(featureName);
+      this.uniqueTrackerSize++;
+    }
+    if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+      this.uniqueTrackerSize = 0;
+      this.onFullQueue();
+    }
+  }
+
+  /**
+   * Clear the data stored on the cache.
+   */
+  clear() {
+    this.uniqueKeysTracker = {};
+  }
+
+  /**
+   * Pop the collected data, used as payload for posting.
+   */
+  pop() {
+    const data = this.uniqueKeysTracker;
+    this.uniqueKeysTracker = {};
+    return this.fromUniqueKeysCollector(data);
+  }
+
+  /**
+   * Check if the cache is empty.
+   */
+  isEmpty() {
+    return Object.keys(this.uniqueKeysTracker).length === 0;
+  }
+
+  /**
+   * Converts `uniqueKeys` data from cache into request payload.
+   */
+  private fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadCs {
+    const payload = [];
+    const featureKeys = Object.keys(uniqueKeys);
+    for (let k = 0; k < featureKeys.length; k++) {
+      const featureKey = featureKeys[k];
+      const featureNames = setToArray(uniqueKeys[featureKey]);
+      const uniqueKeysPayload = {
+        k: featureKey,
+        fs: featureNames
+      };
+
+      payload.push(uniqueKeysPayload);
+    }
+    return { keys: payload };
+  }
+
+}

package/src/storages/inRedis/EventsCacheInRedis.ts

@@ -59,7 +59,7 @@ export class EventsCacheInRedis implements IEventsCacheAsync {
 
   /**
    * Pop the given number of events from the storage.
-   * The returned promise rejects if the wrapper operation fails.
+   * The returned promise rejects if the redis operation fails.
    *
    * NOTE: this method doesn't take into account MAX_EVENT_SIZE or MAX_QUEUE_BYTE_SIZE limits.
    * It is the submitter responsability to handle that.

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -0,0 +1,53 @@
+import { Redis } from 'ioredis';
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { LOG_PREFIX, REFRESH_RATE, TTL_REFRESH } from './constants';
+
+export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
+
+  private readonly log: ILogger;
+  private readonly key: string;
+  private readonly redis: Redis;
+  private readonly refreshRate: number;
+  private intervalId: any;
+
+  constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number, refreshRate = REFRESH_RATE) {
+    super(impressionCountsCacheSize);
+    this.log = log;
+    this.key = key;
+    this.redis = redis;
+    this.refreshRate = refreshRate;
+    this.onFullQueue = () => { this.postImpressionCountsInRedis(); };
+  }
+
+  private postImpressionCountsInRedis(){
+    const counts = this.pop();
+    const keys = Object.keys(counts);
+    if (!keys.length) return Promise.resolve(false);
+
+    const pipeline = this.redis.pipeline();
+    keys.forEach(key => {
+      pipeline.hincrby(this.key, key, counts[key]);
+    });
+    return pipeline.exec()
+      .then(data => {
+        // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
+        if (data.length && data.length === keys.length) {
+          return this.redis.expire(this.key, TTL_REFRESH);
+        }
+      })
+      .catch(err => {
+        this.log.error(`${LOG_PREFIX}Error in impression counts pipeline: ${err}.`);
+        return false;
+      });
+  }
+
+  start() {
+    this.intervalId = setInterval(this.postImpressionCountsInRedis.bind(this), this.refreshRate);
+  }
+
+  stop() {
+    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/TelemetryCacheInRedis.ts

@@ -1,11 +1,14 @@
 import { ILogger } from '../../logger/types';
-import { Method } from '../../sync/submitters/types';
-import { KeyBuilderSS } from '../KeyBuilderSS';
+import { Method, MultiConfigs, MultiMethodExceptions, MultiMethodLatencies } from '../../sync/submitters/types';
+import { KeyBuilderSS, parseExceptionField, parseLatencyField, parseMetadata } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { Redis } from 'ioredis';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
+import { isNaNNumber, isString } from '../../utils/lang';
+import { _Map } from '../../utils/lang/maps';
+import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 
 export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
 
@@ -22,6 +25,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
     return this.redis.hincrby(key, field, 1)
       .catch(() => { /* Handle rejections for telemetry */ });
   }
+
   recordException(method: Method) {
     const [key, field] = this.keys.buildExceptionKey(method).split('::');
     return this.redis.hincrby(key, field, 1)
@@ -33,4 +37,120 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
     const value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, STORAGE_REDIS));
     return this.redis.hset(key, field, value).catch(() => { /* Handle rejections for telemetry */ });
   }
+
+  /**
+   * Pop telemetry latencies.
+   * The returned promise rejects if redis operations fail.
+   */
+  popLatencies(): Promise<MultiMethodLatencies> {
+    return this.redis.hgetall(this.keys.latencyPrefix).then(latencies => {
+
+      const result: MultiMethodLatencies = new _Map();
+
+      Object.keys(latencies).forEach(field => {
+
+        const parsedField = parseLatencyField(field);
+        if (isString(parsedField)) {
+          this.log.error(`Ignoring invalid latency field: ${field}: ${parsedField}`);
+          return;
+        }
+
+        const count = parseInt(latencies[field]);
+        if (isNaNNumber(count)) {
+          this.log.error(`Ignoring latency with invalid count: ${latencies[field]}`);
+          return;
+        }
+
+        const [metadata, method, bucket] = parsedField;
+
+        if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
+          this.log.error(`Ignoring latency with invalid bucket: ${bucket}`);
+          return;
+        }
+
+        if (!result.has(metadata)) result.set(metadata, {
+          t: newBuckets(),
+          ts: newBuckets(),
+          tc: newBuckets(),
+          tcs: newBuckets(),
+          tr: newBuckets(),
+        });
+
+        result.get(metadata)![method][bucket] = count;
+      });
+
+      return this.redis.del(this.keys.latencyPrefix).then(() => result);
+    });
+  }
+
+  /**
+   * Pop telemetry exceptions.
+   * The returned promise rejects if redis operations fail.
+   */
+  popExceptions(): Promise<MultiMethodExceptions> {
+    return this.redis.hgetall(this.keys.exceptionPrefix).then(exceptions => {
+
+      const result: MultiMethodExceptions = new _Map();
+
+      Object.keys(exceptions).forEach(field => {
+
+        const parsedField = parseExceptionField(field);
+        if (isString(parsedField)) {
+          this.log.error(`Ignoring invalid exception field: ${field}: ${parsedField}`);
+          return;
+        }
+
+        const count = parseInt(exceptions[field]);
+        if (isNaNNumber(count)) {
+          this.log.error(`Ignoring exception with invalid count: ${exceptions[field]}`);
+          return;
+        }
+
+        const [metadata, method] = parsedField;
+
+        if (!result.has(metadata)) result.set(metadata, {
+          t: 0,
+          ts: 0,
+          tc: 0,
+          tcs: 0,
+          tr: 0,
+        });
+
+        result.get(metadata)![method] = count;
+      });
+
+      return this.redis.del(this.keys.exceptionPrefix).then(() => result);
+    });
+  }
+
+  /**
+   * Pop telemetry configs.
+   * The returned promise rejects if redis operations fail.
+   */
+  popConfigs(): Promise<MultiConfigs> {
+    return this.redis.hgetall(this.keys.initPrefix).then(configs => {
+
+      const result: MultiConfigs = new _Map();
+
+      Object.keys(configs).forEach(field => {
+
+        const parsedField = parseMetadata(field);
+        if (isString(parsedField)) {
+          this.log.error(`Ignoring invalid config field: ${field}: ${parsedField}`);
+          return;
+        }
+
+        const [metadata] = parsedField;
+
+        try {
+          const config = JSON.parse(configs[field]);
+          result.set(metadata, config);
+        } catch (e) {
+          this.log.error(`Ignoring invalid config: ${configs[field]}`);
+        }
+      });
+
+      return this.redis.del(this.keys.initPrefix).then(() => result);
+    });
+  }
 }

package/src/storages/inRedis/UniqueKeysCacheInRedis.ts

@@ -0,0 +1,65 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { Redis } from 'ioredis';
+import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
+import { setToArray } from '../../utils/lang/sets';
+import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
+import { LOG_PREFIX } from './constants';
+import { ILogger } from '../../logger/types';
+
+export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+
+  private readonly log: ILogger;
+  private readonly key: string;
+  private readonly redis: Redis;
+  private readonly refreshRate: number;
+  private intervalId: any;
+
+  constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize = DEFAULT_CACHE_SIZE, refreshRate = REFRESH_RATE) {
+    super(uniqueKeysQueueSize);
+    this.log = log;
+    this.key = key;
+    this.redis = redis;
+    this.refreshRate = refreshRate;
+    this.onFullQueue = () => {this.postUniqueKeysInRedis();};
+  }
+
+  private postUniqueKeysInRedis() {
+    const featureNames = Object.keys(this.uniqueKeysTracker);
+    if (!featureNames.length) return Promise.resolve(false);
+
+    const pipeline = this.redis.pipeline();
+    for (let i = 0; i < featureNames.length; i++) {
+      const featureName = featureNames[i];
+      const featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
+      const uniqueKeysPayload = {
+        f: featureName,
+        ks: featureKeys
+      };
+
+      pipeline.rpush(this.key, JSON.stringify(uniqueKeysPayload));
+    }
+    this.clear();
+    return pipeline.exec()
+      .then(data => {
+        // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
+        if (data.length && data.length === featureNames.length) {
+          return this.redis.expire(this.key, TTL_REFRESH);
+        }
+      })
+      .catch(err => {
+        this.log.error(`${LOG_PREFIX}Error in uniqueKeys pipeline: ${err}.`);
+        return false;
+      });
+  }
+
+
+  start() {
+    this.intervalId = setInterval(this.postUniqueKeysInRedis.bind(this), this.refreshRate);
+  }
+
+  stop() {
+    clearInterval(this.intervalId);
+    return this.postUniqueKeysInRedis();
+  }
+
+}

package/src/storages/inRedis/constants.ts

@@ -1 +1,4 @@
 export const LOG_PREFIX = 'storage:redis: ';
+export const DEFAULT_CACHE_SIZE = 30000;
+export const REFRESH_RATE = 300000; // 300.000 ms = start after 5 mins
+export const TTL_REFRESH = 3600; // 1hr

package/src/storages/inRedis/index.ts

@@ -6,8 +6,10 @@ import { SplitsCacheInRedis } from './SplitsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
-import { STORAGE_REDIS } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_REDIS } from '../../utils/constants';
 import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
+import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
+import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
 
 export interface InRedisStorageOptions {
   prefix?: string
@@ -22,15 +24,18 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
   const prefix = validatePrefix(options.prefix);
 
-  function InRedisStorageFactory({ log, metadata, onReadyCb }: IStorageFactoryParams): IStorageAsync {
-
+  function InRedisStorageFactory({ log, metadata, onReadyCb, impressionsMode }: IStorageFactoryParams): IStorageAsync {
     const keys = new KeyBuilderSS(prefix, metadata);
     const redisClient = new RedisAdapter(log, options.options || {});
     const telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
+    const impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
+    const uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
 
     // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
     redisClient.on('connect', () => {
       onReadyCb();
+      if (impressionCountsCache) impressionCountsCache.start();
+      if (uniqueKeysCache) uniqueKeysCache.start();
 
       // Synchronize config
       telemetry.recordConfig();
@@ -40,13 +45,18 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
       splits: new SplitsCacheInRedis(log, keys, redisClient),
       segments: new SegmentsCacheInRedis(log, keys, redisClient),
       impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
+      impressionCounts: impressionCountsCache,
       events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
       telemetry,
+      uniqueKeys: uniqueKeysCache,
 
       // When using REDIS we should:
       // 1- Disconnect from the storage
-      destroy() {
-        redisClient.disconnect();
+      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
       }
     };

package/src/storages/pluggable/ImpressionCountsCachePluggable.ts

@@ -0,0 +1,47 @@
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { REFRESH_RATE } from '../inRedis/constants';
+import { IPluggableStorageWrapper } from '../types';
+import { LOG_PREFIX } from './constants';
+
+export class ImpressionCountsCachePluggable extends ImpressionCountsCacheInMemory {
+
+  private readonly log: ILogger;
+  private readonly key: string;
+  private readonly wrapper: IPluggableStorageWrapper;
+  private readonly refreshRate: number;
+  private intervalId: any;
+
+  constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, impressionCountsCacheSize?: number, refreshRate = REFRESH_RATE) {
+    super(impressionCountsCacheSize);
+    this.log = log;
+    this.key = key;
+    this.wrapper = wrapper;
+    this.refreshRate = refreshRate;
+    this.onFullQueue = () => { this.storeImpressionCounts(); };
+  }
+
+  private storeImpressionCounts() {
+    const counts = this.pop();
+    const keys = Object.keys(counts);
+    if (!keys.length) return Promise.resolve(false);
+
+    const pipeline = keys.reduce<Promise<any>>((pipeline, key) => {
+      return pipeline.then(() => this.wrapper.incr(`${this.key}::${key}`, counts[key]));
+    }, Promise.resolve());
+
+    return pipeline.catch(err => {
+      this.log.error(`${LOG_PREFIX}Error in impression counts pipeline: ${err}.`);
+      return false;
+    });
+  }
+
+  start() {
+    this.intervalId = setInterval(this.storeImpressionCounts.bind(this), this.refreshRate);
+  }
+
+  stop() {
+    clearInterval(this.intervalId);
+    return this.storeImpressionCounts();
+  }
+}

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -49,22 +49,22 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplit(name: string, split: string): Promise<boolean> {
+  addSplit(name: string, split: ISplit): Promise<boolean> {
     const splitKey = this.keys.buildSplitKey(name);
     return this.wrapper.get(splitKey).then(splitFromStorage => {
 
       // handling parsing error
-      let parsedPreviousSplit, parsedSplit;
+      let parsedPreviousSplit, stringifiedNewSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        parsedSplit = JSON.parse(split);
+        stringifiedNewSplit = JSON.stringify(split);
       } catch (e) {
         throw new Error('Error parsing split definition: ' + e);
       }
 
       return Promise.all([
-        this.wrapper.set(splitKey, split),
-        this._incrementCounts(parsedSplit),
+        this.wrapper.set(splitKey, stringifiedNewSplit),
+        this._incrementCounts(split),
         // If it's an update, we decrement the traffic type and segment count of the existing split,
         parsedPreviousSplit && this._decrementCounts(parsedPreviousSplit)
       ]);
@@ -76,7 +76,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper 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])));
   }
 
@@ -88,8 +88,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   removeSplit(name: string) {
     return this.getSplit(name).then((split) => {
       if (split) {
-        const parsedSplit = JSON.parse(split);
-        this._decrementCounts(parsedSplit);
+        this._decrementCounts(split);
       }
       return this.wrapper.del(this.keys.buildSplitKey(name));
     });
@@ -109,8 +108,9 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplit(name: string): Promise<string | null> {
-    return this.wrapper.get(this.keys.buildSplitKey(name));
+  getSplit(name: string): Promise<ISplit | null> {
+    return this.wrapper.get(this.keys.buildSplitKey(name))
+      .then(maybeSplit => maybeSplit && JSON.parse(maybeSplit));
   }
 
   /**
@@ -118,13 +118,14 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplits(names: string[]): Promise<Record<string, string | null>> {
+  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
     const keys = names.map(name => this.keys.buildSplitKey(name));
 
     return this.wrapper.getMany(keys).then(splitDefinitions => {
-      const splits: Record<string, string | null> = {};
+      const splits: Record<string, ISplit | null> = {};
       names.forEach((name, idx) => {
-        splits[name] = splitDefinitions[idx];
+        const split = splitDefinitions[idx];
+        splits[name] = split && JSON.parse(split);
       });
       return Promise.resolve(splits);
     });
@@ -135,10 +136,12 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of split definitions,
    * or rejected if wrapper operation fails.
    */
-  getAll(): Promise<string[]> {
-    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(
-      (listOfKeys) => Promise.all(listOfKeys.map(this.wrapper.get) as Promise<string>[])
-    );
+  getAll(): Promise<ISplit[]> {
+    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
+      .then((listOfKeys) => this.wrapper.getMany(listOfKeys))
+      .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
+        return JSON.parse(splitDefinition as string);
+      }));
   }
 
   /**