@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

package/esm/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -1,5 +1,5 @@
 import { setToArray } from '../../utils/lang/sets';
-import { usesSegments } from '../AbstractSplitsCacheSync';
+import { usesSegments } from '../AbstractDefinitionsCacheSync';
 var RBSegmentsCacheInMemory = /** @class */ (function () {
     function RBSegmentsCacheInMemory() {
         this.cache = {};
@@ -14,7 +14,7 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
     RBSegmentsCacheInMemory.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
         var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
+        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove); }).some(function (result) { return result; }) || updated;
         this.changeNumber = changeNumber;
         return updated;
     };

package/esm/storages/inMemory/SegmentsCacheInMemory.js

@@ -1,6 +1,6 @@
 import { isIntegerNumber } from '../../utils/lang';
 /**
- * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
+ * Default IDefinitionsCacheSync implementation for server-side that stores segments definitions in memory.
  */
 var SegmentsCacheInMemory = /** @class */ (function () {
     function SegmentsCacheInMemory() {

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -15,12 +15,12 @@ var ACCEPTANCE_RANGE = 0.001;
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
 export function shouldRecordTelemetry(_a) {
-    var settings = _a.settings;
-    return settings.mode !== LOCALHOST_MODE && (checkIfServerSide(settings) || Math.random() <= ACCEPTANCE_RANGE);
+    var settings = _a.settings, disableTelemetry = _a.disableTelemetry;
+    return !disableTelemetry && settings.mode !== LOCALHOST_MODE && (checkIfServerSide(settings) || Math.random() <= ACCEPTANCE_RANGE);
 }
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(splits, segments, largeSegments) {
-        this.splits = splits;
+    function TelemetryCacheInMemory(definitions, segments, largeSegments) {
+        this.definitions = definitions;
         this.segments = segments;
         this.largeSegments = largeSegments;
         this.name = 'telemetry stats';
@@ -56,7 +56,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             iQ: this.getImpressionStats(QUEUED),
             iDe: this.getImpressionStats(DEDUPED),
             iDr: this.getImpressionStats(DROPPED),
-            spC: this.splits && this.splits.getSplitNames().length,
+            spC: this.definitions && this.definitions.getNames().length,
             seC: this.segments && this.segments.getRegisteredSegments().length,
             skC: this.segments && this.segments.getKeysCount(),
             lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,

package/esm/storages/inRedis/DefinitionsCacheInRedis.js

@@ -0,0 +1,240 @@
+import { __extends, __spreadArray } from "tslib";
+import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
+import { LOG_PREFIX } from './constants';
+import { AbstractDefinitionsCacheAsync } from '../AbstractDefinitionsCacheAsync';
+import { returnDifference } from '../../utils/lang/sets';
+/**
+ * Discard errors for an answer of multiple operations.
+ */
+function processPipelineAnswer(results) {
+    return results ? results.reduce(function (accum, errValuePair) {
+        if (errValuePair[0] === null)
+            accum.push(errValuePair[1]);
+        return accum;
+    }, []) : [];
+}
+/**
+ * IDefinitionsCacheAsync implementation that stores definitions in Redis.
+ * Supported by Node.js
+ */
+var DefinitionsCacheInRedis = /** @class */ (function (_super) {
+    __extends(DefinitionsCacheInRedis, _super);
+    function DefinitionsCacheInRedis(log, keys, redis, splitFiltersValidation) {
+        var _this = _super.call(this) || this;
+        _this.log = log;
+        _this.redis = redis;
+        _this.keys = keys;
+        _this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+        // There is no need to listen for redis 'error' event, because in that case ioredis calls will be rejected and handled by redis storage adapters.
+        // But it is done just to avoid getting the ioredis message `Unhandled error event`.
+        _this.redis.on('error', function (e) {
+            _this.redisError = e;
+        });
+        _this.redis.on('connect', function () {
+            _this.redisError = undefined;
+        });
+        return _this;
+    }
+    DefinitionsCacheInRedis.prototype._decrementCounts = function (definition) {
+        var _this = this;
+        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+        return this.redis.decr(ttKey).then(function (count) {
+            if (count === 0)
+                return _this.redis.del(ttKey);
+        });
+    };
+    DefinitionsCacheInRedis.prototype._incrementCounts = function (definition) {
+        var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+        return this.redis.incr(ttKey);
+    };
+    DefinitionsCacheInRedis.prototype._updateSets = function (definitionName, setsOfRemovedDefinition, setsOfAddedDefinition) {
+        var _this = this;
+        var removeFromSets = returnDifference(setsOfRemovedDefinition, setsOfAddedDefinition);
+        var addToSets = returnDifference(setsOfAddedDefinition, setsOfRemovedDefinition);
+        if (this.setsFilter.length > 0) {
+            addToSets = addToSets.filter(function (set) {
+                return _this.setsFilter.some(function (filterSet) { return filterSet === set; });
+            });
+        }
+        var items = [definitionName];
+        return Promise.all(__spreadArray(__spreadArray([], removeFromSets.map(function (setName) { return _this.redis.srem(_this.keys.buildSetKey(setName), items); }), true), addToSets.map(function (setName) { return _this.redis.sadd(_this.keys.buildSetKey(setName), items); }), true));
+    };
+    /**
+     * Add a given definition.
+     * The returned promise is resolved when the operation success
+     * or rejected if it fails (e.g., redis operation fails)
+     */
+    DefinitionsCacheInRedis.prototype.add = function (definition) {
+        var _this = this;
+        var name = definition.name;
+        var definitionKey = this.keys.buildDefinitionKey(name);
+        return this.redis.get(definitionKey).then(function (definitionFromStorage) {
+            // handling parsing error
+            var parsedPreviousDefinition, stringifiedNewDefinition;
+            try {
+                parsedPreviousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : undefined;
+                stringifiedNewDefinition = JSON.stringify(definition);
+            }
+            catch (e) {
+                throw new Error('Error parsing feature flag definition: ' + e);
+            }
+            return _this.redis.set(definitionKey, stringifiedNewDefinition).then(function () {
+                // avoid unnecessary increment/decrement operations
+                if (parsedPreviousDefinition && parsedPreviousDefinition.trafficTypeName === definition.trafficTypeName)
+                    return;
+                // update traffic type counts
+                return _this._incrementCounts(definition).then(function () {
+                    if (parsedPreviousDefinition)
+                        return _this._decrementCounts(parsedPreviousDefinition);
+                });
+            }).then(function () { return _this._updateSets(name, parsedPreviousDefinition && parsedPreviousDefinition.sets, definition.sets); });
+        }).then(function () { return true; });
+    };
+    /**
+     * Remove a given definition.
+     * The returned promise is resolved when the operation success, with true or false indicating if the definition existed (and was removed) or not.
+     * or rejected if it fails (e.g., redis operation fails).
+     */
+    DefinitionsCacheInRedis.prototype.remove = function (name) {
+        var _this = this;
+        return this.get(name).then(function (definition) {
+            if (definition) {
+                return _this._decrementCounts(definition).then(function () { return _this._updateSets(name, definition.sets); });
+            }
+        }).then(function () {
+            return _this.redis.del(_this.keys.buildDefinitionKey(name)).then(function (status) { return status === 1; });
+        });
+    };
+    /**
+     * Get definition or null if it's not defined.
+     * Returned promise is rejected if redis operation fails.
+     */
+    DefinitionsCacheInRedis.prototype.get = function (name) {
+        if (this.redisError) {
+            this.log.error(LOG_PREFIX + this.redisError);
+            return Promise.reject(this.redisError);
+        }
+        return this.redis.get(this.keys.buildDefinitionKey(name))
+            .then(function (maybeDefinition) { return maybeDefinition && JSON.parse(maybeDefinition); });
+    };
+    /**
+     * Set till number.
+     * The returned promise is resolved when the operation success,
+     * or rejected if it fails.
+     */
+    DefinitionsCacheInRedis.prototype.setChangeNumber = function (changeNumber) {
+        return this.redis.set(this.keys.buildDefinitionsTillKey(), changeNumber + '').then(function (status) { return status === 'OK'; });
+    };
+    /**
+     * Get till number or -1 if it's not defined.
+     * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a redis operation fails.
+     * The promise will never be rejected.
+     */
+    DefinitionsCacheInRedis.prototype.getChangeNumber = function () {
+        var _this = this;
+        return this.redis.get(this.keys.buildDefinitionsTillKey()).then(function (value) {
+            var i = parseInt(value, 10);
+            return isNaNNumber(i) ? -1 : i;
+        }).catch(function (e) {
+            _this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from storage. Error: ' + e);
+            return -1;
+        });
+    };
+    /**
+     * Get list of all definitions.
+     * The returned promise is resolved with the list of definitions,
+     * or rejected if redis operation fails.
+     */
+    // @TODO we need to benchmark which is the maximun number of commands we could pipeline without kill redis performance.
+    DefinitionsCacheInRedis.prototype.getAll = function () {
+        var _this = this;
+        return this.redis.keys(this.keys.searchPatternForDefinitionKeys())
+            .then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
+            .then(processPipelineAnswer)
+            .then(function (definitions) { return definitions.map(function (definition) {
+            return JSON.parse(definition);
+        }); });
+    };
+    /**
+     * Get list of definition names.
+     * The returned promise is resolved with the list of names,
+     * or rejected if redis operation fails.
+     */
+    DefinitionsCacheInRedis.prototype.getNames = function () {
+        var _this = this;
+        return this.redis.keys(this.keys.searchPatternForDefinitionKeys()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
+    };
+    /**
+     * Get list of definition names related to a given list of set names.
+     * The returned promise is resolved with the list of names per set,
+     * or rejected if the pipelined redis operation fails (e.g., timeout).
+    */
+    DefinitionsCacheInRedis.prototype.getNamesBySets = function (sets) {
+        var _this = this;
+        return this.redis.pipeline(sets.map(function (set) { return ['smembers', _this.keys.buildSetKey(set)]; })).exec()
+            .then(function (results) { return results ? results.map(function (_a, index) {
+            var e = _a[0], value = _a[1];
+            if (e === null)
+                return value;
+            _this.log.error(LOG_PREFIX + "Could not read result from get members of set ".concat(sets[index], " due to an error: ").concat(e));
+        }) : []; })
+            .then(function (namesBySets) { return namesBySets.map(function (namesBySet) { return new Set(namesBySet); }); });
+    };
+    /**
+     * Check traffic type existence.
+     * The returned promise is resolved with a boolean indicating whether the TT exist or not.
+     * In case of redis operation failure, the promise resolves with a true value, assuming that the TT might exist.
+     * It will never be rejected.
+     */
+    DefinitionsCacheInRedis.prototype.trafficTypeExists = function (trafficType) {
+        var _this = this;
+        // If there is a number there should be > 0, otherwise the TT is considered as not existent.
+        return this.redis.get(this.keys.buildTrafficTypeKey(trafficType))
+            .then(function (ttCount) {
+            if (ttCount === null)
+                return false; // if entry doesn't exist, means that TT doesn't exist
+            ttCount = parseInt(ttCount, 10);
+            if (!isFiniteNumber(ttCount) || ttCount < 0) {
+                _this.log.info(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to data corruption of some sorts."));
+                return false;
+            }
+            return ttCount > 0;
+        })
+            .catch(function (e) {
+            _this.log.error(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to an error: ").concat(e, "."));
+            // If there is an error, bypass the validation so the event can get tracked.
+            return true;
+        });
+    };
+    // @TODO remove or implement. It is not being used.
+    DefinitionsCacheInRedis.prototype.clear = function () {
+        return Promise.resolve();
+    };
+    /**
+     * Fetches multiple definitions.
+     * Returned promise is rejected if redis operation fails.
+     */
+    DefinitionsCacheInRedis.prototype.getMany = function (names) {
+        var _a;
+        var _this = this;
+        if (this.redisError) {
+            this.log.error(LOG_PREFIX + this.redisError);
+            return Promise.reject(this.redisError);
+        }
+        var keys = names.map(function (name) { return _this.keys.buildDefinitionKey(name); });
+        return (_a = this.redis).mget.apply(_a, keys).then(function (stringifiedDefinitions) {
+            var definitions = {};
+            names.forEach(function (name, idx) {
+                var definition = stringifiedDefinitions[idx];
+                definitions[name] = definition && JSON.parse(definition);
+            });
+            return Promise.resolve(definitions);
+        })
+            .catch(function (e) {
+            _this.log.error(LOG_PREFIX + "Could not grab feature flags due to an error: ".concat(e, "."));
+            return Promise.reject(e);
+        });
+    };
+    return DefinitionsCacheInRedis;
+}(AbstractDefinitionsCacheAsync));
+export { DefinitionsCacheInRedis };

package/esm/storages/inRedis/EventsCacheInRedis.js

@@ -16,7 +16,7 @@ var EventsCacheInRedis = /** @class */ (function () {
             // We use boolean values to signal successful queueing
             .then(function () { return true; })
             .catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error adding event to queue: " + err + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error adding event to queue: ").concat(err, "."));
             return false;
         });
     };

package/esm/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -32,7 +32,7 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
             }
         })
             .catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error in impression counts pipeline: ").concat(err, "."));
             return false;
         });
     };
@@ -55,17 +55,17 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
             forOwn(counts, function (count, key) {
                 var nameAndTime = key.split('::');
                 if (nameAndTime.length !== 2) {
-                    _this.log.error(LOG_PREFIX + "Error spliting key " + key);
+                    _this.log.error("".concat(LOG_PREFIX, "Error spliting key ").concat(key));
                     return;
                 }
                 var timeFrame = parseInt(nameAndTime[1]);
                 if (isNaN(timeFrame)) {
-                    _this.log.error(LOG_PREFIX + "Error parsing time frame " + nameAndTime[1]);
+                    _this.log.error("".concat(LOG_PREFIX, "Error parsing time frame ").concat(nameAndTime[1]));
                     return;
                 }
                 var rawCount = parseInt(count);
                 if (isNaN(rawCount)) {
-                    _this.log.error(LOG_PREFIX + "Error parsing raw count " + count);
+                    _this.log.error("".concat(LOG_PREFIX, "Error parsing raw count ").concat(count));
                     return;
                 }
                 pf.push({

package/esm/storages/inRedis/RBSegmentsCacheInRedis.js

@@ -31,7 +31,7 @@ var RBSegmentsCacheInRedis = /** @class */ (function () {
                 return _this.redis.set(key, stringifiedNewRBSegment).then(function () { return true; });
             })),
             Promise.all(toRemove.map(function (toRemove) {
-                var key = _this.keys.buildRBSegmentKey(toRemove.name);
+                var key = _this.keys.buildRBSegmentKey(toRemove);
                 return _this.redis.del(key).then(function (status) { return status === 1; });
             }))
         ]).then(function (_a) {

package/esm/storages/inRedis/RedisAdapter.js

@@ -58,9 +58,9 @@ var RedisAdapter = /** @class */ (function () {
         var _this = this;
         this.client.once('ready', function () {
             var commandsCount = _this._notReadyCommandsQueue ? _this._notReadyCommandsQueue.length : 0;
-            _this.log.info(LOG_PREFIX + ("Redis connection established. Queued commands: " + commandsCount + "."));
+            _this.log.info(LOG_PREFIX + "Redis connection established. Queued commands: ".concat(commandsCount, "."));
             _this._notReadyCommandsQueue && _this._notReadyCommandsQueue.forEach(function (queued) {
-                _this.log.info(LOG_PREFIX + ("Executing queued " + queued.name + " command."));
+                _this.log.info(LOG_PREFIX + "Executing queued ".concat(queued.name, " command."));
                 queued.command().then(queued.resolve).catch(queued.reject);
             });
             // After the SDK is ready for the first time we'll stop queueing commands. This is just so we can keep handling BUR for them.
@@ -82,7 +82,7 @@ var RedisAdapter = /** @class */ (function () {
                     params[_i] = arguments[_i];
                 }
                 function commandWrapper() {
-                    instance.log.debug(LOG_PREFIX + "Executing " + methodName + ".");
+                    instance.log.debug("".concat(LOG_PREFIX, "Executing ").concat(methodName, "."));
                     var result = originalMethod.apply(bindTarget, params);
                     if (thenable(result)) {
                         // For handling pending commands on disconnect, add to the set and remove once finished.
@@ -94,7 +94,7 @@ var RedisAdapter = /** @class */ (function () {
                         // Both success and error remove from queue.
                         result.then(cleanUpRunningCommandsCb, cleanUpRunningCommandsCb);
                         return timeout(instance._options.operationTimeout, result).catch(function (err) {
-                            instance.log.error("" + LOG_PREFIX + methodName + " operation threw an error or exceeded configured timeout of " + instance._options.operationTimeout + "ms. Message: " + err);
+                            instance.log.error("".concat(LOG_PREFIX).concat(methodName, " operation threw an error or exceeded configured timeout of ").concat(instance._options.operationTimeout, "ms. Message: ").concat(err));
                             // Handling is not the adapter responsibility.
                             throw err;
                         });
@@ -132,7 +132,7 @@ var RedisAdapter = /** @class */ (function () {
                 }
                 var res = originalFn.apply(instance.client, args);
                 var originalExec = res.exec;
-                res.exec = wrapCommand(originalExec, methodName + ".exec", res);
+                res.exec = wrapCommand(originalExec, "".concat(methodName, ".exec"), res);
                 return res;
             };
         });
@@ -147,14 +147,14 @@ var RedisAdapter = /** @class */ (function () {
             }
             setTimeout(function deferredDisconnect() {
                 if (instance._runningCommands.size > 0) {
-                    instance.log.info(LOG_PREFIX + ("Attempting to disconnect but there are " + instance._runningCommands.size + " commands still waiting for resolution. Defering disconnection until those finish."));
+                    instance.log.info(LOG_PREFIX + "Attempting to disconnect but there are ".concat(instance._runningCommands.size, " commands still waiting for resolution. Defering disconnection until those finish."));
                     Promise.all(setToArray(instance._runningCommands))
                         .then(function () {
                         instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
                         originalMethod.apply(instance.client, params);
                     })
                         .catch(function (e) {
-                        instance.log.warn(LOG_PREFIX + ("Pending commands finished with error: " + e + ". Proceeding with disconnection."));
+                        instance.log.warn(LOG_PREFIX + "Pending commands finished with error: ".concat(e, ". Proceeding with disconnection."));
                         originalMethod.apply(instance.client, params);
                     });
                 }

package/esm/storages/inRedis/TelemetryCacheInRedis.js

@@ -42,17 +42,17 @@ var TelemetryCacheInRedis = /** @class */ (function () {
             Object.keys(latencies).forEach(function (field) {
                 var parsedField = parseLatencyField(field);
                 if (isString(parsedField)) {
-                    _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                    _this.log.error("Ignoring invalid latency field: ".concat(field, ": ").concat(parsedField));
                     return;
                 }
                 var count = parseInt(latencies[field]);
                 if (isNaNNumber(count)) {
-                    _this.log.error("Ignoring latency with invalid count: " + latencies[field]);
+                    _this.log.error("Ignoring latency with invalid count: ".concat(latencies[field]));
                     return;
                 }
                 var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
                 if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
-                    _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                    _this.log.error("Ignoring latency with invalid bucket: ".concat(bucket));
                     return;
                 }
                 var methodLatencies = result.get(metadata) || {};
@@ -74,12 +74,12 @@ var TelemetryCacheInRedis = /** @class */ (function () {
             Object.keys(exceptions).forEach(function (field) {
                 var parsedField = parseExceptionField(field);
                 if (isString(parsedField)) {
-                    _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                    _this.log.error("Ignoring invalid exception field: ".concat(field, ": ").concat(parsedField));
                     return;
                 }
                 var count = parseInt(exceptions[field]);
                 if (isNaNNumber(count)) {
-                    _this.log.error("Ignoring exception with invalid count: " + exceptions[field]);
+                    _this.log.error("Ignoring exception with invalid count: ".concat(exceptions[field]));
                     return;
                 }
                 var metadata = parsedField[0], method = parsedField[1];
@@ -101,7 +101,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
             Object.keys(configs).forEach(function (field) {
                 var parsedField = parseMetadata(field);
                 if (isString(parsedField)) {
-                    _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                    _this.log.error("Ignoring invalid config field: ".concat(field, ": ").concat(parsedField));
                     return;
                 }
                 var metadata = parsedField[0];
@@ -110,7 +110,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
                     result.set(metadata, config);
                 }
                 catch (e) {
-                    _this.log.error("Ignoring invalid config: " + configs[field]);
+                    _this.log.error("Ignoring invalid config: ".concat(configs[field]));
                 }
             });
             return _this.redis.del(_this.keys.initPrefix).then(function () { return result; });

package/esm/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -38,7 +38,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
             }
         })
             .catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error in uniqueKeys pipeline: ").concat(err, "."));
             return false;
         });
     };

package/esm/storages/inRedis/index.js

@@ -1,6 +1,6 @@
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderSS } from '../KeyBuilderSS';
-import { SplitsCacheInRedis } from './SplitsCacheInRedis';
+import { DefinitionsCacheInRedis } from './DefinitionsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
@@ -45,7 +45,7 @@ export function InRedisStorage(options) {
             telemetry.recordConfig();
         });
         return {
-            splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
+            definitions: new DefinitionsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
             rbSegments: new RBSegmentsCacheInRedis(log, keys, redisClient),
             segments: new SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),