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

package/cjs/storages/inMemory/{uniqueKeysCacheInMemory.js → UniqueKeysCacheInMemory.js}

@@ -1,8 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniqueKeysCacheInMemory = void 0;
+exports.UniqueKeysCacheInMemory = exports.fromUniqueKeysCollector = void 0;
 var sets_1 = require("../../utils/lang/sets");
 var constants_1 = require("../inRedis/constants");
+/**
+ * Converts `uniqueKeys` data from cache into request payload for SS.
+ */
+function fromUniqueKeysCollector(uniqueKeys) {
+    var payload = [];
+    var featureNames = Object.keys(uniqueKeys);
+    for (var i = 0; i < featureNames.length; i++) {
+        var featureName = featureNames[i];
+        var userKeys = (0, sets_1.setToArray)(uniqueKeys[featureName]);
+        var uniqueKeysPayload = {
+            f: featureName,
+            ks: userKeys
+        };
+        payload.push(uniqueKeysPayload);
+    }
+    return { keys: payload };
+}
+exports.fromUniqueKeysCollector = fromUniqueKeysCollector;
 var UniqueKeysCacheInMemory = /** @class */ (function () {
     function UniqueKeysCacheInMemory(uniqueKeysQueueSize) {
         if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.DEFAULT_CACHE_SIZE; }
@@ -14,16 +32,14 @@ var UniqueKeysCacheInMemory = /** @class */ (function () {
         this.onFullQueue = cb;
     };
     /**
-     * Store unique keys in sequential order
-     * key: string = feature name.
-     * value: Set<string> = set of unique keys.
+     * Store unique keys per feature.
      */
-    UniqueKeysCacheInMemory.prototype.track = function (key, featureName) {
+    UniqueKeysCacheInMemory.prototype.track = function (userKey, featureName) {
         if (!this.uniqueKeysTracker[featureName])
             this.uniqueKeysTracker[featureName] = new sets_1._Set();
         var tracker = this.uniqueKeysTracker[featureName];
-        if (!tracker.has(key)) {
-            tracker.add(key);
+        if (!tracker.has(userKey)) {
+            tracker.add(userKey);
             this.uniqueTrackerSize++;
         }
         if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
@@ -43,7 +59,7 @@ var UniqueKeysCacheInMemory = /** @class */ (function () {
     UniqueKeysCacheInMemory.prototype.pop = function () {
         var data = this.uniqueKeysTracker;
         this.uniqueKeysTracker = {};
-        return this.fromUniqueKeysCollector(data);
+        return fromUniqueKeysCollector(data);
     };
     /**
      * Check if the cache is empty.
@@ -51,23 +67,6 @@ var UniqueKeysCacheInMemory = /** @class */ (function () {
     UniqueKeysCacheInMemory.prototype.isEmpty = function () {
         return Object.keys(this.uniqueKeysTracker).length === 0;
     };
-    /**
-     * Converts `uniqueKeys` data from cache into request payload for SS.
-     */
-    UniqueKeysCacheInMemory.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
-        var payload = [];
-        var featureNames = Object.keys(uniqueKeys);
-        for (var i = 0; i < featureNames.length; i++) {
-            var featureName = featureNames[i];
-            var featureKeys = (0, sets_1.setToArray)(uniqueKeys[featureName]);
-            var uniqueKeysPayload = {
-                f: featureName,
-                ks: featureKeys
-            };
-            payload.push(uniqueKeysPayload);
-        }
-        return { keys: payload };
-    };
     return UniqueKeysCacheInMemory;
 }());
 exports.UniqueKeysCacheInMemory = UniqueKeysCacheInMemory;

package/cjs/storages/inMemory/{uniqueKeysCacheInMemoryCS.js → UniqueKeysCacheInMemoryCS.js}

@@ -19,14 +19,12 @@ var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
         this.onFullQueue = cb;
     };
     /**
-     * Store unique keys in sequential order
-     * key: string = key.
-     * value: HashSet<string> = set of split names.
+     * Store unique keys per feature.
      */
-    UniqueKeysCacheInMemoryCS.prototype.track = function (key, featureName) {
-        if (!this.uniqueKeysTracker[key])
-            this.uniqueKeysTracker[key] = new sets_1._Set();
-        var tracker = this.uniqueKeysTracker[key];
+    UniqueKeysCacheInMemoryCS.prototype.track = function (userKey, featureName) {
+        if (!this.uniqueKeysTracker[userKey])
+            this.uniqueKeysTracker[userKey] = new sets_1._Set();
+        var tracker = this.uniqueKeysTracker[userKey];
         if (!tracker.has(featureName)) {
             tracker.add(featureName);
             this.uniqueTrackerSize++;
@@ -61,12 +59,12 @@ var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
      */
     UniqueKeysCacheInMemoryCS.prototype.fromUniqueKeysCollector = function (uniqueKeys) {
         var payload = [];
-        var featureKeys = Object.keys(uniqueKeys);
-        for (var k = 0; k < featureKeys.length; k++) {
-            var featureKey = featureKeys[k];
-            var featureNames = (0, sets_1.setToArray)(uniqueKeys[featureKey]);
+        var userKeys = Object.keys(uniqueKeys);
+        for (var k = 0; k < userKeys.length; k++) {
+            var userKey = userKeys[k];
+            var featureNames = (0, sets_1.setToArray)(uniqueKeys[userKey]);
             var uniqueKeysPayload = {
-                k: featureKey,
+                k: userKey,
                 fs: featureNames
             };
             payload.push(uniqueKeysPayload);

package/cjs/storages/inRedis/EventsCacheInRedis.js

@@ -42,7 +42,7 @@ var EventsCacheInRedis = /** @class */ (function () {
     };
     /**
      * 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/cjs/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImpressionCountsCacheInRedis = void 0;
 var tslib_1 = require("tslib");
+var lang_1 = require("../../utils/lang");
 var ImpressionCountsCacheInMemory_1 = require("../inMemory/ImpressionCountsCacheInMemory");
 var constants_1 = require("./constants");
 var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
@@ -20,7 +21,7 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         var _this = this;
         var counts = this.pop();
         var keys = Object.keys(counts);
-        if (!keys)
+        if (!keys.length)
             return Promise.resolve(false);
         var pipeline = this.redis.pipeline();
         keys.forEach(function (key) {
@@ -35,7 +36,7 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         })
             .catch(function (err) {
             _this.log.error(constants_1.LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
-            return Promise.resolve(false);
+            return false;
         });
     };
     ImpressionCountsCacheInRedis.prototype.start = function () {
@@ -45,6 +46,40 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
         clearInterval(this.intervalId);
         return this.postImpressionCountsInRedis();
     };
+    // Async consumer API, used by synchronizer
+    ImpressionCountsCacheInRedis.prototype.getImpressionsCount = function () {
+        var _this = this;
+        return this.redis.hgetall(this.key)
+            .then(function (counts) {
+            if (!Object.keys(counts).length)
+                return undefined;
+            _this.redis.del(_this.key).catch(function () { });
+            var pf = [];
+            (0, lang_1.forOwn)(counts, function (count, key) {
+                var nameAndTime = key.split('::');
+                if (nameAndTime.length !== 2) {
+                    _this.log.error(constants_1.LOG_PREFIX + "Error spliting key " + key);
+                    return;
+                }
+                var timeFrame = parseInt(nameAndTime[1]);
+                if (isNaN(timeFrame)) {
+                    _this.log.error(constants_1.LOG_PREFIX + "Error parsing time frame " + nameAndTime[1]);
+                    return;
+                }
+                var rawCount = parseInt(count);
+                if (isNaN(rawCount)) {
+                    _this.log.error(constants_1.LOG_PREFIX + "Error parsing raw count " + count);
+                    return;
+                }
+                pf.push({
+                    f: nameAndTime[0],
+                    m: timeFrame,
+                    rc: rawCount,
+                });
+            });
+            return { pf: pf };
+        });
+    };
     return ImpressionCountsCacheInRedis;
 }(ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory));
 exports.ImpressionCountsCacheInRedis = ImpressionCountsCacheInRedis;

package/cjs/storages/inRedis/ImpressionsCacheInRedis.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImpressionsCacheInRedis = void 0;
+var utils_1 = require("../utils");
 var IMPRESSIONS_TTL_REFRESH = 3600; // 1 hr
 var ImpressionsCacheInRedis = /** @class */ (function () {
     function ImpressionsCacheInRedis(log, key, redis, metadata) {
@@ -11,31 +12,13 @@ var ImpressionsCacheInRedis = /** @class */ (function () {
     }
     ImpressionsCacheInRedis.prototype.track = function (impressions) {
         var _this = this;
-        return this.redis.rpush(this.key, this._toJSON(impressions)).then(function (queuedCount) {
+        return this.redis.rpush(this.key, (0, utils_1.impressionsToJSON)(impressions, this.metadata)).then(function (queuedCount) {
             // If this is the creation of the key on Redis, set the expiration for it in 1hr.
             if (queuedCount === impressions.length) {
                 return _this.redis.expire(_this.key, IMPRESSIONS_TTL_REFRESH);
             }
         });
     };
-    ImpressionsCacheInRedis.prototype._toJSON = function (impressions) {
-        var _this = this;
-        return impressions.map(function (impression) {
-            var keyName = impression.keyName, bucketingKey = impression.bucketingKey, feature = impression.feature, treatment = impression.treatment, label = impression.label, time = impression.time, changeNumber = impression.changeNumber;
-            return JSON.stringify({
-                m: _this.metadata,
-                i: {
-                    k: keyName,
-                    b: bucketingKey,
-                    f: feature,
-                    t: treatment,
-                    r: label,
-                    c: changeNumber,
-                    m: time
-                }
-            });
-        });
-    };
     ImpressionsCacheInRedis.prototype.count = function () {
         return this.redis.llen(this.key).catch(function () { return 0; });
     };

package/cjs/storages/inRedis/TelemetryCacheInRedis.js

@@ -4,6 +4,10 @@ exports.TelemetryCacheInRedis = void 0;
 var findLatencyIndex_1 = require("../findLatencyIndex");
 var telemetrySubmitter_1 = require("../../sync/submitters/telemetrySubmitter");
 var constants_1 = require("../../utils/constants");
+var lang_1 = require("../../utils/lang");
+var maps_1 = require("../../utils/lang/maps");
+var TelemetryCacheInMemory_1 = require("../inMemory/TelemetryCacheInMemory");
+var utils_1 = require("../utils");
 var TelemetryCacheInRedis = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses Redis as storage.
@@ -31,6 +35,102 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         var value = JSON.stringify((0, telemetrySubmitter_1.getTelemetryConfigStats)(constants_1.CONSUMER_MODE, constants_1.STORAGE_REDIS));
         return this.redis.hset(key, field, value).catch(function () { });
     };
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if redis operations fail.
+     */
+    TelemetryCacheInRedis.prototype.popLatencies = function () {
+        var _this = this;
+        return this.redis.hgetall(this.keys.latencyPrefix).then(function (latencies) {
+            var result = new maps_1._Map();
+            Object.keys(latencies).forEach(function (field) {
+                var parsedField = (0, utils_1.parseLatencyField)(field);
+                if ((0, lang_1.isString)(parsedField)) {
+                    _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                    return;
+                }
+                var count = parseInt(latencies[field]);
+                if ((0, lang_1.isNaNNumber)(count)) {
+                    _this.log.error("Ignoring latency with invalid count: " + latencies[field]);
+                    return;
+                }
+                var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
+                if (bucket >= TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT) {
+                    _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                    return;
+                }
+                if (!result.has(metadata))
+                    result.set(metadata, {
+                        t: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                        ts: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                        tc: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                        tcs: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                        tr: (0, TelemetryCacheInMemory_1.newBuckets)(),
+                    });
+                result.get(metadata)[method][bucket] = count;
+            });
+            return _this.redis.del(_this.keys.latencyPrefix).then(function () { return result; });
+        });
+    };
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if redis operations fail.
+     */
+    TelemetryCacheInRedis.prototype.popExceptions = function () {
+        var _this = this;
+        return this.redis.hgetall(this.keys.exceptionPrefix).then(function (exceptions) {
+            var result = new maps_1._Map();
+            Object.keys(exceptions).forEach(function (field) {
+                var parsedField = (0, utils_1.parseExceptionField)(field);
+                if ((0, lang_1.isString)(parsedField)) {
+                    _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                    return;
+                }
+                var count = parseInt(exceptions[field]);
+                if ((0, lang_1.isNaNNumber)(count)) {
+                    _this.log.error("Ignoring exception with invalid count: " + exceptions[field]);
+                    return;
+                }
+                var metadata = parsedField[0], method = parsedField[1];
+                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(function () { return result; });
+        });
+    };
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if redis operations fail.
+     */
+    TelemetryCacheInRedis.prototype.popConfigs = function () {
+        var _this = this;
+        return this.redis.hgetall(this.keys.initPrefix).then(function (configs) {
+            var result = new maps_1._Map();
+            Object.keys(configs).forEach(function (field) {
+                var parsedField = (0, utils_1.parseMetadata)(field);
+                if ((0, lang_1.isString)(parsedField)) {
+                    _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                    return;
+                }
+                var metadata = parsedField[0];
+                try {
+                    var 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(function () { return result; });
+        });
+    };
     return TelemetryCacheInRedis;
 }());
 exports.TelemetryCacheInRedis = TelemetryCacheInRedis;

package/cjs/storages/inRedis/{uniqueKeysCacheInRedis.js → UniqueKeysCacheInRedis.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueKeysCacheInRedis = void 0;
 var tslib_1 = require("tslib");
-var uniqueKeysCacheInMemory_1 = require("../inMemory/uniqueKeysCacheInMemory");
+var UniqueKeysCacheInMemory_1 = require("../inMemory/UniqueKeysCacheInMemory");
 var sets_1 = require("../../utils/lang/sets");
 var constants_1 = require("./constants");
 var constants_2 = require("./constants");
@@ -22,7 +22,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
     UniqueKeysCacheInRedis.prototype.postUniqueKeysInRedis = function () {
         var _this = this;
         var featureNames = Object.keys(this.uniqueKeysTracker);
-        if (!featureNames)
+        if (!featureNames.length)
             return Promise.resolve(false);
         var pipeline = this.redis.pipeline();
         for (var i = 0; i < featureNames.length; i++) {
@@ -44,7 +44,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         })
             .catch(function (err) {
             _this.log.error(constants_2.LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
-            return Promise.resolve(false);
+            return false;
         });
     };
     UniqueKeysCacheInRedis.prototype.start = function () {
@@ -54,6 +54,18 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         clearInterval(this.intervalId);
         return this.postUniqueKeysInRedis();
     };
+    /**
+     * Async consumer API, used by synchronizer.
+     * @param count number of items to pop from the queue. If not provided or equal 0, all items will be popped.
+     */
+    UniqueKeysCacheInRedis.prototype.popNRaw = function (count) {
+        var _this = this;
+        if (count === void 0) { count = 0; }
+        return this.redis.lrange(this.key, 0, count - 1).then(function (uniqueKeyItems) {
+            return _this.redis.ltrim(_this.key, uniqueKeyItems.length, -1)
+                .then(function () { return uniqueKeyItems.map(function (uniqueKeyItem) { return JSON.parse(uniqueKeyItem); }); });
+        });
+    };
     return UniqueKeysCacheInRedis;
-}(uniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory));
+}(UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory));
 exports.UniqueKeysCacheInRedis = UniqueKeysCacheInRedis;

package/cjs/storages/inRedis/index.js

@@ -10,8 +10,9 @@ var ImpressionsCacheInRedis_1 = require("./ImpressionsCacheInRedis");
 var EventsCacheInRedis_1 = require("./EventsCacheInRedis");
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInRedis_1 = require("./TelemetryCacheInRedis");
-var uniqueKeysCacheInRedis_1 = require("./uniqueKeysCacheInRedis");
+var UniqueKeysCacheInRedis_1 = require("./UniqueKeysCacheInRedis");
 var ImpressionCountsCacheInRedis_1 = require("./ImpressionCountsCacheInRedis");
+var utils_1 = require("../utils");
 /**
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
@@ -19,13 +20,14 @@ var ImpressionCountsCacheInRedis_1 = require("./ImpressionCountsCacheInRedis");
 function InRedisStorage(options) {
     if (options === void 0) { options = {}; }
     var prefix = (0, KeyBuilder_1.validatePrefix)(options.prefix);
-    function InRedisStorageFactory(_a) {
-        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, impressionsMode = _a.impressionsMode;
+    function InRedisStorageFactory(params) {
+        var onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, impressionsMode = _a.sync.impressionsMode;
+        var metadata = (0, utils_1.metadataBuilder)(settings);
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
         var redisClient = new RedisAdapter_1.RedisAdapter(log, options.options || {});
         var telemetry = new TelemetryCacheInRedis_1.TelemetryCacheInRedis(log, keys, redisClient);
         var impressionCountsCache = impressionsMode !== constants_1.DEBUG ? new ImpressionCountsCacheInRedis_1.ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
-        var uniqueKeysCache = impressionsMode === constants_1.NONE ? new uniqueKeysCacheInRedis_1.UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
+        var uniqueKeysCache = impressionsMode === constants_1.NONE ? new UniqueKeysCacheInRedis_1.UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
         // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
         redisClient.on('connect', function () {
             onReadyCb();

package/cjs/storages/pluggable/ImpressionCountsCachePluggable.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImpressionCountsCachePluggable = void 0;
+var tslib_1 = require("tslib");
+var ImpressionCountsCacheInMemory_1 = require("../inMemory/ImpressionCountsCacheInMemory");
+var constants_1 = require("../inRedis/constants");
+var constants_2 = require("./constants");
+var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(ImpressionCountsCachePluggable, _super);
+    function ImpressionCountsCachePluggable(log, key, wrapper, impressionCountsCacheSize, refreshRate) {
+        if (refreshRate === void 0) { refreshRate = constants_1.REFRESH_RATE; }
+        var _this = _super.call(this, impressionCountsCacheSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.wrapper = wrapper;
+        _this.refreshRate = refreshRate;
+        _this.onFullQueue = function () { _this.storeImpressionCounts(); };
+        return _this;
+    }
+    ImpressionCountsCachePluggable.prototype.storeImpressionCounts = function () {
+        var _this = this;
+        var counts = this.pop();
+        var keys = Object.keys(counts);
+        if (!keys.length)
+            return Promise.resolve(false);
+        var pipeline = keys.reduce(function (pipeline, key) {
+            return pipeline.then(function () { return _this.wrapper.incr(_this.key + "::" + key, counts[key]); });
+        }, Promise.resolve());
+        return pipeline.catch(function (err) {
+            _this.log.error(constants_2.LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
+            return false;
+        });
+    };
+    ImpressionCountsCachePluggable.prototype.start = function () {
+        this.intervalId = setInterval(this.storeImpressionCounts.bind(this), this.refreshRate);
+    };
+    ImpressionCountsCachePluggable.prototype.stop = function () {
+        clearInterval(this.intervalId);
+        return this.storeImpressionCounts();
+    };
+    // Async consumer API, used by synchronizer
+    ImpressionCountsCachePluggable.prototype.getImpressionsCount = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.key)
+            .then(function (keys) {
+            return keys.length ? Promise.all(keys.map(function (key) { return _this.wrapper.get(key); }))
+                .then(function (counts) {
+                keys.forEach(function (key) { return _this.wrapper.del(key).catch(function () { }); });
+                var pf = [];
+                for (var i = 0; i < keys.length; i++) {
+                    var key = keys[i];
+                    var count = counts[i];
+                    var keyFeatureNameAndTime = key.split('::');
+                    if (keyFeatureNameAndTime.length !== 3) {
+                        _this.log.error(constants_2.LOG_PREFIX + "Error spliting key " + key);
+                        continue;
+                    }
+                    var timeFrame = parseInt(keyFeatureNameAndTime[2]);
+                    if (isNaN(timeFrame)) {
+                        _this.log.error(constants_2.LOG_PREFIX + "Error parsing time frame " + keyFeatureNameAndTime[2]);
+                        continue;
+                    }
+                    // @ts-ignore
+                    var rawCount = parseInt(count);
+                    if (isNaN(rawCount)) {
+                        _this.log.error(constants_2.LOG_PREFIX + "Error parsing raw count " + count);
+                        continue;
+                    }
+                    pf.push({
+                        f: keyFeatureNameAndTime[1],
+                        m: timeFrame,
+                        rc: rawCount,
+                    });
+                }
+                return { pf: pf };
+            }) : undefined;
+        });
+    };
+    return ImpressionCountsCachePluggable;
+}(ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory));
+exports.ImpressionCountsCachePluggable = ImpressionCountsCachePluggable;

package/cjs/storages/pluggable/ImpressionsCachePluggable.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImpressionsCachePluggable = void 0;
+var utils_1 = require("../utils");
 var ImpressionsCachePluggable = /** @class */ (function () {
     function ImpressionsCachePluggable(log, key, wrapper, metadata) {
         this.log = log;
@@ -15,25 +16,7 @@ var ImpressionsCachePluggable = /** @class */ (function () {
      * or rejected if the wrapper operation fails.
      */
     ImpressionsCachePluggable.prototype.track = function (impressions) {
-        return this.wrapper.pushItems(this.key, this._toJSON(impressions));
-    };
-    ImpressionsCachePluggable.prototype._toJSON = function (impressions) {
-        var _this = this;
-        return impressions.map(function (impression) {
-            var keyName = impression.keyName, bucketingKey = impression.bucketingKey, feature = impression.feature, treatment = impression.treatment, label = impression.label, time = impression.time, changeNumber = impression.changeNumber;
-            return JSON.stringify({
-                m: _this.metadata,
-                i: {
-                    k: keyName,
-                    b: bucketingKey,
-                    f: feature,
-                    t: treatment,
-                    r: label,
-                    c: changeNumber,
-                    m: time
-                }
-            });
-        });
+        return this.wrapper.pushItems(this.key, (0, utils_1.impressionsToJSON)(impressions, this.metadata));
     };
     /**
      * Returns a promise that resolves with the count of stored impressions, or 0 if there was some error.