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

package/cjs/storages/pluggable/ImpressionCountsCachePluggable.js

@@ -0,0 +1,43 @@
+"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();
+    };
+    return ImpressionCountsCachePluggable;
+}(ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory));
+exports.ImpressionCountsCachePluggable = ImpressionCountsCachePluggable;

package/cjs/storages/pluggable/SplitsCachePluggable.js

@@ -49,17 +49,17 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         var splitKey = this.keys.buildSplitKey(name);
         return this.wrapper.get(splitKey).then(function (splitFromStorage) {
             // handling parsing error
-            var parsedPreviousSplit, parsedSplit;
+            var parsedPreviousSplit, stringifiedNewSplit;
             try {
                 parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-                parsedSplit = JSON.parse(split);
+                stringifiedNewSplit = JSON.stringify(split);
             }
             catch (e) {
                 throw new Error('Error parsing split definition: ' + e);
             }
             return Promise.all([
-                _this.wrapper.set(splitKey, split),
-                _this._incrementCounts(parsedSplit),
+                _this.wrapper.set(splitKey, stringifiedNewSplit),
+                _this._incrementCounts(split),
                 // If it's an update, we decrement the traffic type and segment count of the existing split,
                 parsedPreviousSplit && _this._decrementCounts(parsedPreviousSplit)
             ]);
@@ -83,8 +83,7 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         var _this = this;
         return this.getSplit(name).then(function (split) {
             if (split) {
-                var parsedSplit = JSON.parse(split);
-                _this._decrementCounts(parsedSplit);
+                _this._decrementCounts(split);
             }
             return _this.wrapper.del(_this.keys.buildSplitKey(name));
         });
@@ -104,7 +103,8 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
      * or rejected if wrapper operation fails.
      */
     SplitsCachePluggable.prototype.getSplit = function (name) {
-        return this.wrapper.get(this.keys.buildSplitKey(name));
+        return this.wrapper.get(this.keys.buildSplitKey(name))
+            .then(function (maybeSplit) { return maybeSplit && JSON.parse(maybeSplit); });
     };
     /**
      * Get list of splits.
@@ -117,7 +117,8 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         return this.wrapper.getMany(keys).then(function (splitDefinitions) {
             var splits = {};
             names.forEach(function (name, idx) {
-                splits[name] = splitDefinitions[idx];
+                var split = splitDefinitions[idx];
+                splits[name] = split && JSON.parse(split);
             });
             return Promise.resolve(splits);
         });
@@ -129,7 +130,11 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
      */
     SplitsCachePluggable.prototype.getAll = function () {
         var _this = this;
-        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(function (listOfKeys) { return Promise.all(listOfKeys.map(_this.wrapper.get)); });
+        return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
+            .then(function (listOfKeys) { return _this.wrapper.getMany(listOfKeys); })
+            .then(function (splitDefinitions) { return splitDefinitions.map(function (splitDefinition) {
+            return JSON.parse(splitDefinition);
+        }); });
     };
     /**
      * Get list of split names.

package/cjs/storages/pluggable/TelemetryCachePluggable.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelemetryCachePluggable = void 0;
+var KeyBuilderSS_1 = require("../KeyBuilderSS");
 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 TelemetryCachePluggable = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses a storage wrapper.
@@ -22,6 +28,126 @@ var TelemetryCachePluggable = /** @class */ (function () {
         return this.wrapper.incr(this.keys.buildExceptionKey(method))
             .catch(function () { });
     };
+    TelemetryCachePluggable.prototype.recordConfig = function () {
+        var value = JSON.stringify((0, telemetrySubmitter_1.getTelemetryConfigStats)(constants_1.CONSUMER_MODE, constants_1.STORAGE_PLUGGABLE));
+        return this.wrapper.set(this.keys.buildInitKey(), value).catch(function () { });
+    };
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popLatencies = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.latencyPrefix).then(function (latencyKeys) {
+            return latencyKeys.length ?
+                _this.wrapper.getMany(latencyKeys).then(function (latencies) {
+                    var result = new maps_1._Map();
+                    for (var i = 0; i < latencyKeys.length; i++) {
+                        var field = latencyKeys[i].split('::')[1];
+                        var parsedField = (0, KeyBuilderSS_1.parseLatencyField)(field);
+                        if ((0, lang_1.isString)(parsedField)) {
+                            _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        // @ts-ignore
+                        var count = parseInt(latencies[i]);
+                        if ((0, lang_1.isNaNNumber)(count)) {
+                            _this.log.error("Ignoring latency with invalid count: " + latencies[i]);
+                            continue;
+                        }
+                        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);
+                            continue;
+                        }
+                        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 Promise.all(latencyKeys.map(function (latencyKey) { return _this.wrapper.del(latencyKey); })).then(function () { return result; });
+                }) :
+                // If latencyKeys is empty, return an empty map.
+                new maps_1._Map();
+        });
+    };
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popExceptions = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.exceptionPrefix).then(function (exceptionKeys) {
+            return exceptionKeys.length ?
+                _this.wrapper.getMany(exceptionKeys).then(function (exceptions) {
+                    var result = new maps_1._Map();
+                    for (var i = 0; i < exceptionKeys.length; i++) {
+                        var field = exceptionKeys[i].split('::')[1];
+                        var parsedField = (0, KeyBuilderSS_1.parseExceptionField)(field);
+                        if ((0, lang_1.isString)(parsedField)) {
+                            _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        // @ts-ignore
+                        var count = parseInt(exceptions[i]);
+                        if ((0, lang_1.isNaNNumber)(count)) {
+                            _this.log.error("Ignoring exception with invalid count: " + exceptions[i]);
+                            continue;
+                        }
+                        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 Promise.all(exceptionKeys.map(function (exceptionKey) { return _this.wrapper.del(exceptionKey); })).then(function () { return result; });
+                }) :
+                // If exceptionKeys is empty, return an empty map.
+                new maps_1._Map();
+        });
+    };
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if wrapper operations fail.
+     */
+    TelemetryCachePluggable.prototype.popConfigs = function () {
+        var _this = this;
+        return this.wrapper.getKeysByPrefix(this.keys.initPrefix).then(function (configKeys) {
+            return configKeys.length ?
+                _this.wrapper.getMany(configKeys).then(function (configs) {
+                    var result = new maps_1._Map();
+                    for (var i = 0; i < configKeys.length; i++) {
+                        var field = configKeys[i].split('::')[1];
+                        var parsedField = (0, KeyBuilderSS_1.parseMetadata)(field);
+                        if ((0, lang_1.isString)(parsedField)) {
+                            _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                            continue;
+                        }
+                        var metadata = parsedField[0];
+                        try { // @ts-ignore
+                            var config = JSON.parse(configs[i]);
+                            result.set(metadata, config);
+                        }
+                        catch (e) {
+                            _this.log.error("Ignoring invalid config: " + configs[i]);
+                        }
+                    }
+                    return Promise.all(configKeys.map(function (configKey) { return _this.wrapper.del(configKey); })).then(function () { return result; });
+                }) :
+                // If configKeys is empty, return an empty map.
+                new maps_1._Map();
+        });
+    };
     return TelemetryCachePluggable;
 }());
 exports.TelemetryCachePluggable = TelemetryCachePluggable;

package/cjs/storages/pluggable/UniqueKeysCachePluggable.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueKeysCachePluggable = void 0;
+var tslib_1 = require("tslib");
+var UniqueKeysCacheInMemory_1 = require("../inMemory/UniqueKeysCacheInMemory");
+var sets_1 = require("../../utils/lang/sets");
+var constants_1 = require("../inRedis/constants");
+var constants_2 = require("./constants");
+var UniqueKeysCachePluggable = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(UniqueKeysCachePluggable, _super);
+    function UniqueKeysCachePluggable(log, key, wrapper, uniqueKeysQueueSize, refreshRate) {
+        if (uniqueKeysQueueSize === void 0) { uniqueKeysQueueSize = constants_1.DEFAULT_CACHE_SIZE; }
+        if (refreshRate === void 0) { refreshRate = constants_1.REFRESH_RATE; }
+        var _this = _super.call(this, uniqueKeysQueueSize) || this;
+        _this.log = log;
+        _this.key = key;
+        _this.wrapper = wrapper;
+        _this.refreshRate = refreshRate;
+        _this.onFullQueue = function () { _this.storeUniqueKeys(); };
+        return _this;
+    }
+    UniqueKeysCachePluggable.prototype.storeUniqueKeys = function () {
+        var _this = this;
+        var featureNames = Object.keys(this.uniqueKeysTracker);
+        if (!featureNames.length)
+            return Promise.resolve(false);
+        var pipeline = featureNames.reduce(function (pipeline, featureName) {
+            var featureKeys = (0, sets_1.setToArray)(_this.uniqueKeysTracker[featureName]);
+            var uniqueKeysPayload = {
+                f: featureName,
+                ks: featureKeys
+            };
+            return pipeline.then(function () { return _this.wrapper.pushItems(_this.key, [JSON.stringify(uniqueKeysPayload)]); });
+        }, Promise.resolve());
+        this.clear();
+        return pipeline.catch(function (err) {
+            _this.log.error(constants_2.LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
+            return false;
+        });
+    };
+    UniqueKeysCachePluggable.prototype.start = function () {
+        this.intervalId = setInterval(this.storeUniqueKeys.bind(this), this.refreshRate);
+    };
+    UniqueKeysCachePluggable.prototype.stop = function () {
+        clearInterval(this.intervalId);
+        return this.storeUniqueKeys();
+    };
+    return UniqueKeysCachePluggable;
+}(UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory));
+exports.UniqueKeysCachePluggable = UniqueKeysCachePluggable;

package/cjs/storages/pluggable/index.js

@@ -14,6 +14,12 @@ var constants_1 = require("../../utils/constants");
 var ImpressionsCacheInMemory_1 = require("../inMemory/ImpressionsCacheInMemory");
 var EventsCacheInMemory_1 = require("../inMemory/EventsCacheInMemory");
 var ImpressionCountsCacheInMemory_1 = require("../inMemory/ImpressionCountsCacheInMemory");
+var TelemetryCacheInMemory_1 = require("../inMemory/TelemetryCacheInMemory");
+var TelemetryCachePluggable_1 = require("./TelemetryCachePluggable");
+var ImpressionCountsCachePluggable_1 = require("./ImpressionCountsCachePluggable");
+var UniqueKeysCachePluggable_1 = require("./UniqueKeysCachePluggable");
+var UniqueKeysCacheInMemory_1 = require("../inMemory/UniqueKeysCacheInMemory");
+var UniqueKeysCacheInMemoryCS_1 = require("../inMemory/UniqueKeysCacheInMemoryCS");
 var NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 var NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
 /**
@@ -30,15 +36,6 @@ function validatePluggableStorageOptions(options) {
     if (missingMethods.length)
         throw new Error(NO_VALID_WRAPPER_INTERFACE + " The following methods are missing or invalid: " + missingMethods);
 }
-// subscription to wrapper connect event in order to emit SDK_READY event
-function wrapperConnect(wrapper, onReadyCb) {
-    wrapper.connect().then(function () {
-        onReadyCb();
-        // At the moment, we don't synchronize config with pluggable storage
-    }).catch(function (e) {
-        onReadyCb(e || new Error('Error connecting wrapper'));
-    });
-}
 // Async return type in `client.track` method on consumer partial mode
 // No need to promisify impressions cache
 function promisifyEventsTrack(events) {
@@ -54,28 +51,56 @@ function promisifyEventsTrack(events) {
 function PluggableStorage(options) {
     validatePluggableStorageOptions(options);
     var prefix = (0, KeyBuilder_1.validatePrefix)(options.prefix);
-    function PluggableStorageFactory(_a) {
-        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, mode = _a.mode, eventsQueueSize = _a.eventsQueueSize, impressionsQueueSize = _a.impressionsQueueSize, optimize = _a.optimize;
+    function PluggableStorageFactory(params) {
+        var log = params.log, metadata = params.metadata, onReadyCb = params.onReadyCb, mode = params.mode, eventsQueueSize = params.eventsQueueSize, impressionsQueueSize = params.impressionsQueueSize, impressionsMode = params.impressionsMode, matchingKey = params.matchingKey;
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
         var wrapper = (0, wrapperAdapter_1.wrapperAdapter)(log, options.wrapper);
         var isPartialConsumer = mode === constants_1.CONSUMER_PARTIAL_MODE;
+        var telemetry = (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ?
+            isPartialConsumer ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : new TelemetryCachePluggable_1.TelemetryCachePluggable(log, keys, wrapper) :
+            undefined;
+        var impressionCountsCache = impressionsMode !== constants_1.DEBUG ?
+            isPartialConsumer ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : new ImpressionCountsCachePluggable_1.ImpressionCountsCachePluggable(log, keys.buildImpressionsCountKey(), wrapper) :
+            undefined;
+        var uniqueKeysCache = impressionsMode === constants_1.NONE ?
+            isPartialConsumer ?
+                matchingKey === undefined ? new UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() :
+                new UniqueKeysCachePluggable_1.UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
+            undefined;
         // Connects to wrapper and emits SDK_READY event on main client
-        wrapperConnect(wrapper, onReadyCb);
+        var connectPromise = wrapper.connect().then(function () {
+            onReadyCb();
+            // Start periodic flush of async storages
+            if (impressionCountsCache && impressionCountsCache.start)
+                impressionCountsCache.start();
+            if (uniqueKeysCache && uniqueKeysCache.start)
+                uniqueKeysCache.start();
+            // If mode is not defined, it means that the synchronizer is running and so we don't have to record telemetry
+            if (telemetry && telemetry.recordConfig && mode)
+                telemetry.recordConfig();
+        }).catch(function (e) {
+            e = e || new Error('Error connecting wrapper');
+            onReadyCb(e);
+            return e;
+        });
         return {
             splits: new SplitsCachePluggable_1.SplitsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable_1.SegmentsCachePluggable(log, keys, wrapper),
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable_1.ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
-            impressionCounts: optimize ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
+            impressionCounts: impressionCountsCache,
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable_1.EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-            // @TODO Not using TelemetryCachePluggable yet because it's not supported by the Split Synchronizer, and needs to drop or queue operations while the wrapper is not ready
-            // telemetry: isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper),
+            telemetry: telemetry,
+            uniqueKeys: uniqueKeysCache,
             // Disconnect the underlying storage
             destroy: function () {
-                return wrapper.disconnect();
+                return Promise.all([
+                    impressionCountsCache && impressionCountsCache.stop && impressionCountsCache.stop(),
+                    uniqueKeysCache && uniqueKeysCache.stop && uniqueKeysCache.stop(),
+                ]).then(function () { return wrapper.disconnect(); });
             },
             // emits SDK_READY event on shared clients and returns a reference to the storage
             shared: function (_, onReadyCb) {
-                wrapperConnect(wrapper, onReadyCb);
+                connectPromise.then(onReadyCb);
                 return (0, tslib_1.__assign)((0, tslib_1.__assign)({}, this), { 
                     // no-op destroy, to disconnect the wrapper only when the main client is destroyed
                     destroy: function () { } });

package/cjs/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -27,8 +27,7 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
             log.debug(constants_3.SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
             (0, lang_1.forOwn)(splitsMock, function (val, name) {
                 splits.push([
-                    name,
-                    JSON.stringify({
+                    name, {
                         name: name,
                         status: 'ACTIVE',
                         killed: false,
@@ -37,7 +36,7 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                         conditions: val.conditions || [],
                         configurations: val.configurations,
                         trafficTypeName: val.trafficTypeName
-                    })
+                    }
                 ]);
             });
             return Promise.all([

package/cjs/sync/polling/updaters/splitChangesUpdater.js

@@ -41,7 +41,7 @@ function computeSplitsMutation(entries) {
     var segments = new sets_1._Set();
     var computed = entries.reduce(function (accum, split) {
         if (split.status === 'ACTIVE') {
-            accum.added.push([split.name, JSON.stringify(split)]);
+            accum.added.push([split.name, split]);
             parseSegments(split).forEach(function (segmentName) {
                 segments.add(segmentName);
             });

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -9,6 +9,7 @@ var settingsValidation_1 = require("../../utils/settingsValidation");
 var apiKey_1 = require("../../utils/inputValidation/apiKey");
 var timer_1 = require("../../utils/timeTracker/timer");
 var objectAssign_1 = require("../../utils/lang/objectAssign");
+var utils_1 = require("../../trackers/impressionObserver/utils");
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
  */
@@ -29,9 +30,9 @@ function telemetryCacheStatsAdapter(telemetry, splits, segments) {
                 iQ: telemetry.getImpressionStats(constants_1.QUEUED),
                 iDe: telemetry.getImpressionStats(constants_1.DEDUPED),
                 iDr: telemetry.getImpressionStats(constants_1.DROPPED),
-                spC: splits.getSplitNames().length,
-                seC: segments.getRegisteredSegments().length,
-                skC: segments.getKeysCount(),
+                spC: splits && splits.getSplitNames().length,
+                seC: segments && segments.getRegisteredSegments().length,
+                skC: segments && segments.getKeysCount(),
                 sL: telemetry.getSessionLength(),
                 eQ: telemetry.getEventStats(constants_1.QUEUED),
                 eD: telemetry.getEventStats(constants_1.DROPPED),
@@ -50,6 +51,7 @@ var OPERATION_MODE_MAP = (_a = {},
 var IMPRESSIONS_MODE_MAP = (_b = {},
     _b[constants_1.OPTIMIZED] = constants_1.OPTIMIZED_ENUM,
     _b[constants_1.DEBUG] = constants_1.DEBUG_ENUM,
+    _b[constants_1.NONE] = constants_1.NONE_ENUM,
     _b);
 var USER_CONSENT_MAP = (_c = {},
     _c[constants_1.CONSENT_UNKNOWN] = 1,
@@ -125,7 +127,9 @@ function telemetrySubmitterFactory(params) {
         return; // No submitter created if telemetry cache is not defined
     var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
     var startTime = (0, timer_1.timer)(now);
-    var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
+    var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, splitApi.postMetricsUsage, 
+    // @TODO cannot provide splits and segments cache if they are async, because `submitterFactory` expects a sync storage source
+    (0, utils_1.isStorageSync)(params.settings) ? telemetryCacheStatsAdapter(telemetry, splits, segments) : telemetryCacheStatsAdapter(telemetry), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(constants_2.SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());
     });

package/cjs/sync/submitters/uniqueKeysSubmitter.js

@@ -1,70 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uniqueKeysSubmitterFactory = exports.fromUniqueKeysCollectorSs = exports.fromUniqueKeysCollectorCs = void 0;
-var sets_1 = require("../../utils/lang/sets");
+exports.uniqueKeysSubmitterFactory = void 0;
+var constants_1 = require("../../logger/constants");
 var submitter_1 = require("./submitter");
-/**
- * Invert keys for feature to features for key
- */
-function invertUniqueKeys(uniqueKeys) {
-    var featureNames = Object.keys(uniqueKeys);
-    var inverted = {};
-    for (var i = 0; i < featureNames.length; i++) {
-        var featureName = featureNames[i];
-        var featureKeys = (0, sets_1.setToArray)(uniqueKeys[featureName]);
-        for (var j = 0; j < featureKeys.length; j++) {
-            var featureKey = featureKeys[j];
-            if (!inverted[featureKey])
-                inverted[featureKey] = [];
-            inverted[featureKey].push(featureName);
-        }
-    }
-    return inverted;
-}
-/**
- * Converts `uniqueKeys` data from cache into request payload for CS.
- */
-function fromUniqueKeysCollectorCs(uniqueKeys) {
-    var payload = [];
-    var featuresPerKey = invertUniqueKeys(uniqueKeys);
-    var keys = Object.keys(featuresPerKey);
-    for (var k = 0; k < keys.length; k++) {
-        var key = keys[k];
-        var uniqueKeysPayload = {
-            k: key,
-            fs: featuresPerKey[key]
-        };
-        payload.push(uniqueKeysPayload);
-    }
-    return { keys: payload };
-}
-exports.fromUniqueKeysCollectorCs = fromUniqueKeysCollectorCs;
-/**
- * Converts `uniqueKeys` data from cache into request payload for SS.
- */
-function fromUniqueKeysCollectorSs(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 };
-}
-exports.fromUniqueKeysCollectorSs = fromUniqueKeysCollectorSs;
+var DATA_NAME = 'unique keys';
+var UNIQUE_KEYS_RATE = 900000; // 15 minutes
 /**
  * Submitter that periodically posts impression counts
  */
 function uniqueKeysSubmitterFactory(params) {
-    var _a = params.settings, log = _a.log, uniqueKeysRefreshRate = _a.scheduler.uniqueKeysRefreshRate, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
+    var _a = params.settings, log = _a.log, key = _a.core.key, _b = params.splitApi, postUniqueKeysBulkCs = _b.postUniqueKeysBulkCs, postUniqueKeysBulkSs = _b.postUniqueKeysBulkSs, uniqueKeys = params.storage.uniqueKeys;
     var isClientSide = key !== undefined;
     var postUniqueKeysBulk = isClientSide ? postUniqueKeysBulkCs : postUniqueKeysBulkSs;
-    var fromUniqueKeysCollector = isClientSide ? fromUniqueKeysCollectorCs : fromUniqueKeysCollectorSs;
-    return (0, submitter_1.submitterFactory)(log, postUniqueKeysBulk, uniqueKeys, uniqueKeysRefreshRate, 'unique keys', fromUniqueKeysCollector);
+    var syncTask = (0, submitter_1.submitterFactory)(log, postUniqueKeysBulk, uniqueKeys, UNIQUE_KEYS_RATE, DATA_NAME);
+    // register unique keys submitter to be executed when uniqueKeys cache is full
+    uniqueKeys.setOnFullQueueCb(function () {
+        if (syncTask.isRunning()) {
+            log.info(constants_1.SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+            syncTask.execute();
+        }
+        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
+        // Data will be sent when submitter is resumed.
+    });
+    return syncTask;
 }
 exports.uniqueKeysSubmitterFactory = uniqueKeysSubmitterFactory;

package/cjs/trackers/impressionsTracker.js

@@ -23,21 +23,23 @@ function impressionsTrackerFactory(settings, impressionsCache, strategy, integra
             var impressionsCount = impressions.length;
             var _a = strategy.process(impressions), impressionsToStore = _a.impressionsToStore, impressionsToListener = _a.impressionsToListener, deduped = _a.deduped;
             var impressionsToListenerCount = impressionsToListener.length;
-            var res = impressionsCache.track(impressionsToStore);
-            // If we're on an async storage, handle error and log it.
-            if ((0, thenable_1.thenable)(res)) {
-                res.then(function () {
-                    log.info(constants_1.IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
-                }).catch(function (err) {
-                    log.error(constants_1.ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
-                });
-            }
-            else {
-                // Record when impressionsCache is sync only (standalone mode)
-                // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-                if (telemetryCache) {
-                    telemetryCache.recordImpressionStats(constants_2.QUEUED, impressionsToStore.length);
-                    telemetryCache.recordImpressionStats(constants_2.DEDUPED, deduped);
+            if (impressionsToStore.length > 0) {
+                var res = impressionsCache.track(impressionsToStore);
+                // If we're on an async storage, handle error and log it.
+                if ((0, thenable_1.thenable)(res)) {
+                    res.then(function () {
+                        log.info(constants_1.IMPRESSIONS_TRACKER_SUCCESS, [impressionsCount]);
+                    }).catch(function (err) {
+                        log.error(constants_1.ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
+                    });
+                }
+                else {
+                    // Record when impressionsCache is sync only (standalone mode)
+                    // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
+                    if (telemetryCache) {
+                        telemetryCache.recordImpressionStats(constants_2.QUEUED, impressionsToStore.length);
+                        telemetryCache.recordImpressionStats(constants_2.DEDUPED, deduped);
+                    }
                 }
             }
             // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor

package/cjs/trackers/strategy/strategyNone.js

@@ -16,7 +16,7 @@ function strategyNoneFactory(impressionsCounter, uniqueKeysTracker) {
                 // Increments impression counter per featureName
                 impressionsCounter.track(impression.feature, now, 1);
                 // Keep track by unique key
-                uniqueKeysTracker.track(impression.feature, impression.keyName);
+                uniqueKeysTracker.track(impression.keyName, impression.feature);
             });
             return {
                 impressionsToStore: [],

package/cjs/trackers/strategy/strategyOptimized.js

@@ -17,7 +17,8 @@ function strategyOptimizedFactory(impressionsObserver, impressionsCounter) {
                 impression.pt = impressionsObserver.testAndSet(impression);
                 var now = Date.now();
                 // Increments impression counter per featureName
-                impressionsCounter.track(impression.feature, now, 1);
+                if (impression.pt)
+                    impressionsCounter.track(impression.feature, now, 1);
                 // Checks if the impression should be added in queue to be sent
                 if (!impression.pt || impression.pt < (0, time_1.truncateTimeFrame)(now)) {
                     impressionsToStore.push(impression);

package/cjs/trackers/telemetryTracker.js

@@ -49,6 +49,11 @@ function telemetryTrackerFactory(telemetryCache, now) {
                     if (e === constants_1.TOKEN_REFRESH)
                         telemetryCache.recordTokenRefreshes();
                 }
+            },
+            addTag: function (tag) {
+                // @ts-ignore
+                if (telemetryCache.addTag)
+                    telemetryCache.addTag(tag);
             }
         };
     }
@@ -59,6 +64,7 @@ function telemetryTrackerFactory(telemetryCache, now) {
             trackHttp: noopTrack,
             sessionLength: function () { },
             streamingEvent: function () { },
+            addTag: function () { }
         };
     }
 }