@splitsoftware/splitio-commons 1.12.1-rc.1 → 1.12.1-rc.2

package/CHANGES.txt

@@ -1,6 +1,7 @@
 1.12.0 (December XX, 2023)
  - Added support for Flag Sets in "consumer" and "partial consumer" modes for Pluggable and Redis storages.
  - Updated evaluation flow to log a warning when using flag sets that don't contain cached feature flags.
+ - Updated Redis adapter to wrap missing commands: 'hincrby', 'popNRaw', 'flushdb' and 'pipeline.exec'.
 
 1.11.0 (November 3, 2023)
   - Added support for Flag Sets on the SDK, which enables grouping feature flags and interacting with the group rather than individually (more details in our documentation):
@@ -57,7 +58,7 @@
  - Added a new impressions mode for the SDK called NONE, to be used in factory when there is no desire to capture impressions on an SDK factory to feed Split's analytics engine. Running NONE mode, the SDK will only capture unique keys evaluated for a particular feature flag instead of full blown impressions.
  - Updated SDK telemetry to support pluggable storage, partial consumer mode, and synchronizer.
  - Updated storage implementations to improve the performance of feature flag evaluations (i.e., `getTreatment(s)` method calls) when using the default storage in memory.
- - Updated evaluation flow to avoid unnecessarily storage calls when the SDK is not ready.
+ - Updated evaluation flow (i.e., `getTreatment(s)` method calls) to avoid calling the storage for cached feature flags when the SDK is not ready or ready from cache. It applies to all SDK modes.
 
 1.6.1 (July 22, 2022)
  - Updated GoogleAnalyticsToSplit integration to validate `autoRequire` config parameter and avoid some wrong warning logs when mapping GA hit fields to Split event properties.

package/cjs/sdkClient/client.js

@@ -4,8 +4,8 @@ exports.clientFactory = void 0;
 var evaluator_1 = require("../evaluator");
 var thenable_1 = require("../utils/promise/thenable");
 var key_1 = require("../utils/key");
-var splitExistance_1 = require("../utils/inputValidation/splitExistance");
-var trafficTypeExistance_1 = require("../utils/inputValidation/trafficTypeExistance");
+var splitExistence_1 = require("../utils/inputValidation/splitExistence");
+var trafficTypeExistence_1 = require("../utils/inputValidation/trafficTypeExistence");
 var labels_1 = require("../utils/labels");
 var constants_1 = require("../utils/constants");
 var constants_2 = require("../logger/constants");
@@ -102,7 +102,7 @@ function clientFactory(params) {
         var bucketingKey = (0, key_1.getBucketing)(key);
         var treatment = evaluation.treatment, label = evaluation.label, changeNumber = evaluation.changeNumber, _a = evaluation.config, config = _a === void 0 ? null : _a;
         log.info(constants_2.IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
-        if ((0, splitExistance_1.validateSplitExistance)(log, readinessManager, featureFlagName, label, invokingMethodName)) {
+        if ((0, splitExistence_1.validateSplitExistence)(log, readinessManager, featureFlagName, label, invokingMethodName)) {
             log.info(constants_2.IMPRESSION_QUEUEING);
             queue.push({
                 feature: featureFlagName,
@@ -136,7 +136,7 @@ function clientFactory(params) {
             properties: properties
         };
         // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
-        (0, trafficTypeExistance_1.validateTrafficTypeExistance)(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
+        (0, trafficTypeExistence_1.validateTrafficTypeExistence)(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
         var result = eventTracker.track(eventData, size);
         if ((0, thenable_1.thenable)(result)) {
             return result.then(function (result) {

package/cjs/sdkManager/index.js

@@ -57,11 +57,11 @@ function sdkManagerFactory(log, splits, _a) {
             var split = splits.getSplit(splitName);
             if ((0, thenable_1.thenable)(split)) {
                 return split.catch(function () { return null; }).then(function (result) {
-                    (0, inputValidation_1.validateSplitExistance)(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
+                    (0, inputValidation_1.validateSplitExistence)(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
                     return objectToView(result);
                 });
             }
-            (0, inputValidation_1.validateSplitExistance)(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
+            (0, inputValidation_1.validateSplitExistence)(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
             return objectToView(split);
         },
         /**

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -246,9 +246,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 return;
             var flagSetKey = _this.keys.buildFlagSetKey(featureFlagSet);
             var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            if (!flagSetFromLocalStorage)
-                flagSetFromLocalStorage = '[]';
-            var flagSetCache = new sets_1._Set(JSON.parse(flagSetFromLocalStorage));
+            var flagSetCache = new sets_1._Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
             flagSetCache.add(featureFlag.name);
             localStorage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
         });

package/cjs/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -23,11 +23,7 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         var keys = Object.keys(counts);
         if (!keys.length)
             return Promise.resolve(false);
-        var pipeline = this.redis.pipeline();
-        keys.forEach(function (key) {
-            pipeline.hincrby(_this.key, key, counts[key]);
-        });
-        return pipeline.exec()
+        return this.redis.pipelineExec(keys.map(function (key) { return ['hincrby', _this.key, key, counts[key]]; }))
             .then(function (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) {

package/cjs/storages/inRedis/RedisAdapter.js

@@ -9,7 +9,7 @@ var thenable_1 = require("../../utils/promise/thenable");
 var timeout_1 = require("../../utils/promise/timeout");
 var LOG_PREFIX = 'storage:redis-adapter: ';
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim', 'hset'];
+var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw', 'flushdb', 'pipelineExec'];
 // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
 var DEFAULT_OPTIONS = {
     connectionTimeout: 10000,
@@ -40,6 +40,9 @@ var RedisAdapter = /** @class */ (function (_super) {
         _this._setDisconnectWrapper();
         return _this;
     }
+    RedisAdapter.prototype.pipelineExec = function (commands) {
+        return this.pipeline(commands).exec();
+    };
     RedisAdapter.prototype._listenToEvents = function () {
         var _this = this;
         this.once('ready', function () {
@@ -58,13 +61,12 @@ var RedisAdapter = /** @class */ (function (_super) {
     };
     RedisAdapter.prototype._setTimeoutWrappers = function () {
         var instance = this;
-        METHODS_TO_PROMISE_WRAP.forEach(function (method) {
-            var originalMethod = instance[method];
-            instance[method] = function () {
+        METHODS_TO_PROMISE_WRAP.forEach(function (methodName) {
+            var originalMethod = instance[methodName];
+            instance[methodName] = function () {
                 var params = arguments;
                 function commandWrapper() {
-                    instance.log.debug(LOG_PREFIX + ("Executing " + method + "."));
-                    // Return original method
+                    instance.log.debug(LOG_PREFIX + "Executing " + methodName + ".");
                     var result = originalMethod.apply(instance, params);
                     if ((0, thenable_1.thenable)(result)) {
                         // For handling pending commands on disconnect, add to the set and remove once finished.
@@ -76,7 +78,7 @@ var RedisAdapter = /** @class */ (function (_super) {
                         // Both success and error remove from queue.
                         result.then(cleanUpRunningCommandsCb, cleanUpRunningCommandsCb);
                         return (0, timeout_1.timeout)(instance._options.operationTimeout, result).catch(function (err) {
-                            instance.log.error(LOG_PREFIX + (method + " operation threw an error or exceeded configured timeout of " + instance._options.operationTimeout + "ms. Message: " + err));
+                            instance.log.error("" + LOG_PREFIX + methodName + " operation threw an error or exceeded configured timeout of " + instance._options.operationTimeout + "ms. Message: " + err);
                             // Handling is not the adapter responsibility.
                             throw err;
                         });
@@ -89,7 +91,7 @@ var RedisAdapter = /** @class */ (function (_super) {
                             resolve: res,
                             reject: rej,
                             command: commandWrapper,
-                            name: method.toUpperCase()
+                            name: methodName.toUpperCase()
                         });
                     });
                 }
@@ -107,7 +109,7 @@ var RedisAdapter = /** @class */ (function (_super) {
             for (var _i = 0; _i < arguments.length; _i++) {
                 params[_i] = arguments[_i];
             }
-            setTimeout(function deferedDisconnect() {
+            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."));
                     Promise.all((0, sets_1.setToArray)(instance._runningCommands))
@@ -158,7 +160,7 @@ var RedisAdapter = /** @class */ (function (_super) {
      * Parses the options into what we care about.
      */
     RedisAdapter._defineOptions = function (_a) {
-        var connectionTimeout = _a.connectionTimeout, operationTimeout = _a.operationTimeout, url = _a.url, host = _a.host, port = _a.port, db = _a.db, pass = _a.pass, tls = _a.tls;
+        var _b = _a === void 0 ? {} : _a, connectionTimeout = _b.connectionTimeout, operationTimeout = _b.operationTimeout, url = _b.url, host = _b.host, port = _b.port, db = _b.db, pass = _b.pass, tls = _b.tls;
         var parsedOptions = {
             connectionTimeout: connectionTimeout,
             operationTimeout: operationTimeout,

package/cjs/storages/inRedis/SplitsCacheInRedis.js

@@ -171,7 +171,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     SplitsCacheInRedis.prototype.getAll = function () {
         var _this = this;
         return this.redis.keys(this.keys.searchPatternForSplitKeys())
-            .then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
+            .then(function (listOfKeys) { return _this.redis.pipelineExec(listOfKeys.map(function (k) { return ['get', k]; })); })
             .then(processPipelineAnswer)
             .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
             return JSON.parse(splitDefinition);
@@ -187,16 +187,20 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
     };
     /**
-     * Get list of split names related to a given flag set names list.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if any wrapper operation fails.
+     * Get list of feature flag names related to a given list of flag set names.
+     * The returned promise is resolved with the list of feature flag names per flag set,
+     * or rejected if the pipelined redis operation fails.
     */
     SplitsCacheInRedis.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
-        return Promise.all(flagSets.map(function (flagSet) {
-            var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
-            return _this.redis.smembers(flagSetKey);
-        })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new sets_1._Set(namesByFlagSet); }); });
+        return this.redis.pipelineExec(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; }))
+            .then(function (results) { return results.map(function (_a, index) {
+            var e = _a[0], value = _a[1];
+            if (e === null)
+                return value;
+            _this.log.error(constants_1.LOG_PREFIX + ("Could not read result from get members of flag set " + flagSets[index] + " due to an error: " + e));
+        }); })
+            .then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new sets_1._Set(namesByFlagSet); }); });
     };
     /**
      * Check traffic type existence.
@@ -213,13 +217,13 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
                 return false; // if entry doesn't exist, means that TT doesn't exist
             ttCount = parseInt(ttCount, 10);
             if (!(0, lang_1.isFiniteNumber)(ttCount) || ttCount < 0) {
-                _this.log.info(constants_1.LOG_PREFIX + ("Could not validate traffic type existance of " + trafficType + " due to data corruption of some sorts."));
+                _this.log.info(constants_1.LOG_PREFIX + ("Could not validate traffic type existence of " + trafficType + " due to data corruption of some sorts."));
                 return false;
             }
             return ttCount > 0;
         })
             .catch(function (e) {
-            _this.log.error(constants_1.LOG_PREFIX + ("Could not validate traffic type existance of " + trafficType + " due to an error: " + e + "."));
+            _this.log.error(constants_1.LOG_PREFIX + ("Could not validate traffic type existence of " + trafficType + " due to an error: " + e + "."));
             // If there is an error, bypass the validation so the event can get tracked.
             return true;
         });

package/cjs/storages/pluggable/SplitsCachePluggable.js

@@ -161,15 +161,15 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
     };
     /**
-     * Get list of split names related to a given flag set names list.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if any wrapper operation fails.
-    */
+     * Get list of feature flag names related to a given list of flag set names.
+     * The returned promise is resolved with the list of feature flag names per flag set.
+     * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
+     */
     SplitsCachePluggable.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
         return Promise.all(flagSets.map(function (flagSet) {
             var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
-            return _this.wrapper.getItems(flagSetKey);
+            return _this.wrapper.getItems(flagSetKey).catch(function () { return []; });
         })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new sets_1._Set(namesByFlagSet); }); });
     };
     /**

package/cjs/utils/inputValidation/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatePreloadedData = exports.validateTrafficTypeExistance = exports.validateSplitExistance = exports.validateIfOperational = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateSplits = exports.validateSplit = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
+exports.validatePreloadedData = exports.validateTrafficTypeExistence = exports.validateSplitExistence = exports.validateIfOperational = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateSplits = exports.validateSplit = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
 var apiKey_1 = require("./apiKey");
 Object.defineProperty(exports, "validateApiKey", { enumerable: true, get: function () { return apiKey_1.validateApiKey; } });
 Object.defineProperty(exports, "validateAndTrackApiKey", { enumerable: true, get: function () { return apiKey_1.validateAndTrackApiKey; } });
@@ -24,9 +24,9 @@ Object.defineProperty(exports, "validateTrafficType", { enumerable: true, get: f
 var isOperational_1 = require("./isOperational");
 Object.defineProperty(exports, "validateIfNotDestroyed", { enumerable: true, get: function () { return isOperational_1.validateIfNotDestroyed; } });
 Object.defineProperty(exports, "validateIfOperational", { enumerable: true, get: function () { return isOperational_1.validateIfOperational; } });
-var splitExistance_1 = require("./splitExistance");
-Object.defineProperty(exports, "validateSplitExistance", { enumerable: true, get: function () { return splitExistance_1.validateSplitExistance; } });
-var trafficTypeExistance_1 = require("./trafficTypeExistance");
-Object.defineProperty(exports, "validateTrafficTypeExistance", { enumerable: true, get: function () { return trafficTypeExistance_1.validateTrafficTypeExistance; } });
+var splitExistence_1 = require("./splitExistence");
+Object.defineProperty(exports, "validateSplitExistence", { enumerable: true, get: function () { return splitExistence_1.validateSplitExistence; } });
+var trafficTypeExistence_1 = require("./trafficTypeExistence");
+Object.defineProperty(exports, "validateTrafficTypeExistence", { enumerable: true, get: function () { return trafficTypeExistence_1.validateTrafficTypeExistence; } });
 var preloadedData_1 = require("./preloadedData");
 Object.defineProperty(exports, "validatePreloadedData", { enumerable: true, get: function () { return preloadedData_1.validatePreloadedData; } });

package/cjs/utils/inputValidation/{splitExistance.js → splitExistence.js}

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSplitExistance = void 0;
+exports.validateSplitExistence = void 0;
 var labels_1 = require("../labels");
 var constants_1 = require("../../logger/constants");
 /**
  * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
  * But it's not going to run on the input validation layer. In any case, the most compeling reason to use it as we do is to avoid going to Redis and get a split twice.
  */
-function validateSplitExistance(log, readinessManager, splitName, labelOrSplitObj, method) {
+function validateSplitExistence(log, readinessManager, splitName, labelOrSplitObj, method) {
     if (readinessManager.isReady()) { // Only if it's ready we validate this, otherwise it may just be that the SDK is not ready yet.
         if (labelOrSplitObj === labels_1.SPLIT_NOT_FOUND || labelOrSplitObj == null) {
             log.warn(constants_1.WARN_NOT_EXISTENT_SPLIT, [method, splitName]);
@@ -16,4 +16,4 @@ function validateSplitExistance(log, readinessManager, splitName, labelOrSplitOb
     }
     return true;
 }
-exports.validateSplitExistance = validateSplitExistance;
+exports.validateSplitExistence = validateSplitExistence;

package/cjs/utils/inputValidation/{trafficTypeExistance.js → trafficTypeExistence.js}

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateTrafficTypeExistance = void 0;
+exports.validateTrafficTypeExistence = void 0;
 var thenable_1 = require("../promise/thenable");
 var constants_1 = require("../constants");
 var constants_2 = require("../../logger/constants");
-function logTTExistanceWarning(log, maybeTT, method) {
+function logTTExistenceWarning(log, maybeTT, method) {
     log.warn(constants_2.WARN_NOT_EXISTENT_TT, [method, maybeTT]);
 }
 /**
  * Separated from the previous method since on some cases it'll be async.
  */
-function validateTrafficTypeExistance(log, readinessManager, splitsCache, mode, maybeTT, method) {
+function validateTrafficTypeExistence(log, readinessManager, splitsCache, mode, maybeTT, method) {
     // If not ready or in localhost mode, we won't run the validation
     if (!readinessManager.isReady() || mode === constants_1.LOCALHOST_MODE)
         return true;
@@ -18,14 +18,14 @@ function validateTrafficTypeExistance(log, readinessManager, splitsCache, mode,
     if ((0, thenable_1.thenable)(res)) {
         return res.then(function (isValid) {
             if (!isValid)
-                logTTExistanceWarning(log, maybeTT, method);
+                logTTExistenceWarning(log, maybeTT, method);
             return isValid; // propagate result
         });
     }
     else {
         if (!res)
-            logTTExistanceWarning(log, maybeTT, method);
+            logTTExistenceWarning(log, maybeTT, method);
         return res;
     }
 }
-exports.validateTrafficTypeExistance = validateTrafficTypeExistance;
+exports.validateTrafficTypeExistence = validateTrafficTypeExistence;

package/cjs/utils/redis/RedisMock.js

@@ -9,22 +9,16 @@ function asyncFunction(data) {
     return Promise.resolve(data);
 }
 var IDENTITY_METHODS = [];
-var ASYNC_METHODS = ['rpush', 'hincrby'];
-var PIPELINE_METHODS = ['rpush', 'hincrby'];
+var ASYNC_METHODS = ['rpush', 'hincrby', 'pipelineExec'];
 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;
 }());

package/esm/sdkClient/client.js

@@ -1,8 +1,8 @@
 import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } from '../evaluator';
 import { thenable } from '../utils/promise/thenable';
 import { getMatching, getBucketing } from '../utils/key';
-import { validateSplitExistance } from '../utils/inputValidation/splitExistance';
-import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';
+import { validateSplitExistence } from '../utils/inputValidation/splitExistence';
+import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
 import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET } from '../utils/constants';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
@@ -99,7 +99,7 @@ export function clientFactory(params) {
         var bucketingKey = getBucketing(key);
         var treatment = evaluation.treatment, label = evaluation.label, changeNumber = evaluation.changeNumber, _a = evaluation.config, config = _a === void 0 ? null : _a;
         log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
-        if (validateSplitExistance(log, readinessManager, featureFlagName, label, invokingMethodName)) {
+        if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
             log.info(IMPRESSION_QUEUEING);
             queue.push({
                 feature: featureFlagName,
@@ -133,7 +133,7 @@ export function clientFactory(params) {
             properties: properties
         };
         // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
-        validateTrafficTypeExistance(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
+        validateTrafficTypeExistence(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
         var result = eventTracker.track(eventData, size);
         if (thenable(result)) {
             return result.then(function (result) {

package/esm/sdkManager/index.js

@@ -1,7 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
-import { validateSplit, validateSplitExistance, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
+import { validateSplit, validateSplitExistence, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
 var SPLIT_FN_LABEL = 'split';
 var SPLITS_FN_LABEL = 'splits';
 var NAMES_FN_LABEL = 'names';
@@ -54,11 +54,11 @@ export function sdkManagerFactory(log, splits, _a) {
             var split = splits.getSplit(splitName);
             if (thenable(split)) {
                 return split.catch(function () { return null; }).then(function (result) {
-                    validateSplitExistance(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
+                    validateSplitExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
                     return objectToView(result);
                 });
             }
-            validateSplitExistance(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
+            validateSplitExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
             return objectToView(split);
         },
         /**

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -243,9 +243,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 return;
             var flagSetKey = _this.keys.buildFlagSetKey(featureFlagSet);
             var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            if (!flagSetFromLocalStorage)
-                flagSetFromLocalStorage = '[]';
-            var flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+            var flagSetCache = new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
             flagSetCache.add(featureFlag.name);
             localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
         });

package/esm/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -20,11 +20,7 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         var keys = Object.keys(counts);
         if (!keys.length)
             return Promise.resolve(false);
-        var pipeline = this.redis.pipeline();
-        keys.forEach(function (key) {
-            pipeline.hincrby(_this.key, key, counts[key]);
-        });
-        return pipeline.exec()
+        return this.redis.pipelineExec(keys.map(function (key) { return ['hincrby', _this.key, key, counts[key]]; }))
             .then(function (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) {

package/esm/storages/inRedis/RedisAdapter.js

@@ -6,7 +6,7 @@ import { thenable } from '../../utils/promise/thenable';
 import { timeout } from '../../utils/promise/timeout';
 var LOG_PREFIX = 'storage:redis-adapter: ';
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim', 'hset'];
+var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw', 'flushdb', 'pipelineExec'];
 // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
 var DEFAULT_OPTIONS = {
     connectionTimeout: 10000,
@@ -37,6 +37,9 @@ var RedisAdapter = /** @class */ (function (_super) {
         _this._setDisconnectWrapper();
         return _this;
     }
+    RedisAdapter.prototype.pipelineExec = function (commands) {
+        return this.pipeline(commands).exec();
+    };
     RedisAdapter.prototype._listenToEvents = function () {
         var _this = this;
         this.once('ready', function () {
@@ -55,13 +58,12 @@ var RedisAdapter = /** @class */ (function (_super) {
     };
     RedisAdapter.prototype._setTimeoutWrappers = function () {
         var instance = this;
-        METHODS_TO_PROMISE_WRAP.forEach(function (method) {
-            var originalMethod = instance[method];
-            instance[method] = function () {
+        METHODS_TO_PROMISE_WRAP.forEach(function (methodName) {
+            var originalMethod = instance[methodName];
+            instance[methodName] = function () {
                 var params = arguments;
                 function commandWrapper() {
-                    instance.log.debug(LOG_PREFIX + ("Executing " + method + "."));
-                    // Return original method
+                    instance.log.debug(LOG_PREFIX + "Executing " + methodName + ".");
                     var result = originalMethod.apply(instance, params);
                     if (thenable(result)) {
                         // For handling pending commands on disconnect, add to the set and remove once finished.
@@ -73,7 +75,7 @@ var RedisAdapter = /** @class */ (function (_super) {
                         // 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 + (method + " operation threw an error or exceeded configured timeout of " + instance._options.operationTimeout + "ms. Message: " + err));
+                            instance.log.error("" + LOG_PREFIX + methodName + " operation threw an error or exceeded configured timeout of " + instance._options.operationTimeout + "ms. Message: " + err);
                             // Handling is not the adapter responsibility.
                             throw err;
                         });
@@ -86,7 +88,7 @@ var RedisAdapter = /** @class */ (function (_super) {
                             resolve: res,
                             reject: rej,
                             command: commandWrapper,
-                            name: method.toUpperCase()
+                            name: methodName.toUpperCase()
                         });
                     });
                 }
@@ -104,7 +106,7 @@ var RedisAdapter = /** @class */ (function (_super) {
             for (var _i = 0; _i < arguments.length; _i++) {
                 params[_i] = arguments[_i];
             }
-            setTimeout(function deferedDisconnect() {
+            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."));
                     Promise.all(setToArray(instance._runningCommands))
@@ -155,7 +157,7 @@ var RedisAdapter = /** @class */ (function (_super) {
      * Parses the options into what we care about.
      */
     RedisAdapter._defineOptions = function (_a) {
-        var connectionTimeout = _a.connectionTimeout, operationTimeout = _a.operationTimeout, url = _a.url, host = _a.host, port = _a.port, db = _a.db, pass = _a.pass, tls = _a.tls;
+        var _b = _a === void 0 ? {} : _a, connectionTimeout = _b.connectionTimeout, operationTimeout = _b.operationTimeout, url = _b.url, host = _b.host, port = _b.port, db = _b.db, pass = _b.pass, tls = _b.tls;
         var parsedOptions = {
             connectionTimeout: connectionTimeout,
             operationTimeout: operationTimeout,

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -168,7 +168,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
     SplitsCacheInRedis.prototype.getAll = function () {
         var _this = this;
         return this.redis.keys(this.keys.searchPatternForSplitKeys())
-            .then(function (listOfKeys) { return _this.redis.pipeline(listOfKeys.map(function (k) { return ['get', k]; })).exec(); })
+            .then(function (listOfKeys) { return _this.redis.pipelineExec(listOfKeys.map(function (k) { return ['get', k]; })); })
             .then(processPipelineAnswer)
             .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
             return JSON.parse(splitDefinition);
@@ -184,16 +184,20 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
     };
     /**
-     * Get list of split names related to a given flag set names list.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if any wrapper operation fails.
+     * Get list of feature flag names related to a given list of flag set names.
+     * The returned promise is resolved with the list of feature flag names per flag set,
+     * or rejected if the pipelined redis operation fails.
     */
     SplitsCacheInRedis.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
-        return Promise.all(flagSets.map(function (flagSet) {
-            var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
-            return _this.redis.smembers(flagSetKey);
-        })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new _Set(namesByFlagSet); }); });
+        return this.redis.pipelineExec(flagSets.map(function (flagSet) { return ['smembers', _this.keys.buildFlagSetKey(flagSet)]; }))
+            .then(function (results) { return 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 flag set " + flagSets[index] + " due to an error: " + e));
+        }); })
+            .then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new _Set(namesByFlagSet); }); });
     };
     /**
      * Check traffic type existence.
@@ -210,13 +214,13 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
                 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 existance of " + trafficType + " due to data corruption of some sorts."));
+                _this.log.info(LOG_PREFIX + ("Could not validate traffic type existence of " + 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 existance of " + trafficType + " due to an error: " + e + "."));
+            _this.log.error(LOG_PREFIX + ("Could not validate traffic type existence of " + trafficType + " due to an error: " + e + "."));
             // If there is an error, bypass the validation so the event can get tracked.
             return true;
         });

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -158,15 +158,15 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
     };
     /**
-     * Get list of split names related to a given flag set names list.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if any wrapper operation fails.
-    */
+     * Get list of feature flag names related to a given list of flag set names.
+     * The returned promise is resolved with the list of feature flag names per flag set.
+     * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
+     */
     SplitsCachePluggable.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
         return Promise.all(flagSets.map(function (flagSet) {
             var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
-            return _this.wrapper.getItems(flagSetKey);
+            return _this.wrapper.getItems(flagSetKey).catch(function () { return []; });
         })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new _Set(namesByFlagSet); }); });
     };
     /**

package/esm/utils/inputValidation/index.js

@@ -8,6 +8,6 @@ export { validateSplit } from './split';
 export { validateSplits } from './splits';
 export { validateTrafficType } from './trafficType';
 export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
-export { validateSplitExistance } from './splitExistance';
-export { validateTrafficTypeExistance } from './trafficTypeExistance';
+export { validateSplitExistence } from './splitExistence';
+export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validatePreloadedData } from './preloadedData';

package/esm/utils/inputValidation/{splitExistance.js → splitExistence.js}

@@ -4,7 +4,7 @@ import { WARN_NOT_EXISTENT_SPLIT } from '../../logger/constants';
  * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
  * But it's not going to run on the input validation layer. In any case, the most compeling reason to use it as we do is to avoid going to Redis and get a split twice.
  */
-export function validateSplitExistance(log, readinessManager, splitName, labelOrSplitObj, method) {
+export function validateSplitExistence(log, readinessManager, splitName, labelOrSplitObj, method) {
     if (readinessManager.isReady()) { // Only if it's ready we validate this, otherwise it may just be that the SDK is not ready yet.
         if (labelOrSplitObj === SPLIT_NOT_FOUND || labelOrSplitObj == null) {
             log.warn(WARN_NOT_EXISTENT_SPLIT, [method, splitName]);