@splitsoftware/splitio-commons 1.6.2-rc.12 → 1.6.2-rc.14

package/cjs/listeners/browser.js

@@ -7,7 +7,6 @@ var constants_1 = require("../utils/constants");
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_2 = require("../logger/constants");
 var consent_1 = require("../consent");
-var telemetrySubmitter_1 = require("../sync/submitters/telemetrySubmitter");
 var VISIBILITYCHANGE_EVENT = 'visibilitychange';
 var PAGEHIDE_EVENT = 'pagehide';
 var UNLOAD_EVENT = 'unload';
@@ -71,25 +70,25 @@ var BrowserSignalListener = /** @class */ (function () {
     BrowserSignalListener.prototype.flushData = function () {
         if (!this.syncManager)
             return; // In consumer mode there is not sync manager and data to flush
+        var _a = this.settings.urls, events = _a.events, telemetry = _a.telemetry;
         // Flush impressions & events data if there is user consent
         if ((0, consent_1.isConsentGranted)(this.settings)) {
-            var eventsUrl = this.settings.urls.events;
             var sim = this.settings.sync.impressionsMode;
             var extraMetadata = {
                 // sim stands for Sync/Split Impressions Mode
                 sim: sim === constants_1.OPTIMIZED ? constants_1.OPTIMIZED : sim === constants_1.DEBUG ? constants_1.DEBUG : constants_1.NONE
             };
-            this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
-            this._flushData(eventsUrl + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
+            this._flushData(events + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
+            this._flushData(events + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
             if (this.storage.impressionCounts)
-                this._flushData(eventsUrl + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, impressionCountsSubmitter_1.fromImpressionCountsCollector);
+                this._flushData(events + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, impressionCountsSubmitter_1.fromImpressionCountsCollector);
+            // @ts-ignore
+            if (this.storage.uniqueKeys)
+                this._flushData(telemetry + '/v1/keys/cs/beacon', this.storage.uniqueKeys, this.serviceApi.postUniqueKeysBulkCs);
         }
         // Flush telemetry data
-        if (this.storage.telemetry) {
-            var telemetryUrl = this.settings.urls.telemetry;
-            var telemetryCacheAdapter = (0, telemetrySubmitter_1.telemetryCacheStatsAdapter)(this.storage.telemetry, this.storage.splits, this.storage.segments);
-            this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
-        }
+        if (this.storage.telemetry)
+            this._flushData(telemetry + '/v1/metrics/usage/beacon', this.storage.telemetry, this.serviceApi.postMetricsUsage);
     };
     BrowserSignalListener.prototype.flushDataIfHidden = function () {
         // Precondition: document defined
@@ -103,7 +102,6 @@ var BrowserSignalListener = /** @class */ (function () {
             if (!this._sendBeacon(url, dataPayload, extraMetadata)) {
                 postService(JSON.stringify(dataPayload)).catch(function () { }); // no-op just to catch a possible exception
             }
-            cache.clear();
         }
     };
     /**

package/cjs/sdkFactory/index.js

@@ -5,12 +5,9 @@ var sdkReadinessManager_1 = require("../readiness/sdkReadinessManager");
 var impressionsTracker_1 = require("../trackers/impressionsTracker");
 var eventTracker_1 = require("../trackers/eventTracker");
 var telemetryTracker_1 = require("../trackers/telemetryTracker");
-var key_1 = require("../utils/key");
-var utils_1 = require("../trackers/impressionObserver/utils");
 var apiKey_1 = require("../utils/inputValidation/apiKey");
 var sdkLogger_1 = require("../logger/sdkLogger");
 var constants_1 = require("../logger/constants");
-var metadataBuilder_1 = require("../storages/metadataBuilder");
 var constants_2 = require("../readiness/constants");
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var strategyDebug_1 = require("../trackers/strategy/strategyDebug");
@@ -23,43 +20,29 @@ var constants_3 = require("../utils/constants");
  */
 function sdkFactory(params) {
     var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory;
-    var log = settings.log;
+    var log = settings.log, impressionsMode = settings.sync.impressionsMode;
     // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid API Key, etc.
     // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
     // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
     (0, apiKey_1.validateAndTrackApiKey)(log, settings.core.authorizationKey);
     var sdkReadinessManager = (0, sdkReadinessManager_1.sdkReadinessManagerFactory)(log, platform.EventEmitter, settings.startup.readyTimeout);
     var readiness = sdkReadinessManager.readinessManager;
-    // @TODO consider passing the settings object, so that each storage access only what it needs
-    var storageFactoryParams = {
-        impressionsQueueSize: settings.scheduler.impressionsQueueSize,
-        eventsQueueSize: settings.scheduler.eventsQueueSize,
-        optimize: (0, utils_1.shouldBeOptimized)(settings),
-        // ATM, only used by InLocalStorage
-        matchingKey: (0, key_1.getMatching)(settings.core.key),
-        splitFiltersValidation: settings.sync.__splitFiltersValidation,
-        // ATM, only used by PluggableStorage
-        mode: settings.mode,
-        impressionsMode: settings.sync.impressionsMode,
-        // Callback used to emit SDK_READY in consumer mode, where `syncManagerFactory` is undefined,
-        // or partial consumer mode, where it only has submitters, and therefore it doesn't emit readiness events.
+    var storage = storageFactory({
+        settings: settings,
         onReadyCb: function (error) {
             if (error)
                 return; // Don't emit SDK_READY if storage failed to connect. Error message is logged by wrapperAdapter
             readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
             readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
         },
-        metadata: (0, metadataBuilder_1.metadataBuilder)(settings),
-        log: log
-    };
-    var storage = storageFactory(storageFactoryParams);
+    });
     // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
     var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
     var observer = impressionsObserverFactory();
-    var uniqueKeysTracker = storageFactoryParams.impressionsMode === constants_3.NONE ? (0, uniqueKeysTracker_1.uniqueKeysTrackerFactory)(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory()) : undefined;
+    var uniqueKeysTracker = impressionsMode === constants_3.NONE ? (0, uniqueKeysTracker_1.uniqueKeysTrackerFactory)(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory()) : undefined;
     var strategy;
-    switch (storageFactoryParams.impressionsMode) {
+    switch (impressionsMode) {
         case constants_3.OPTIMIZED:
             strategy = (0, strategyOptimized_1.strategyOptimizedFactory)(observer, storage.impressionCounts);
             break;
@@ -94,7 +77,7 @@ function sdkFactory(params) {
             return managerInstance;
         },
         // Logger wrapper API
-        Logger: (0, sdkLogger_1.createLoggerAPI)(settings.log),
+        Logger: (0, sdkLogger_1.createLoggerAPI)(log),
         settings: settings,
     }, extraProps && extraProps(ctx));
 }

package/cjs/storages/KeyBuilderSS.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseLatencyField = exports.parseExceptionField = exports.parseMetadata = exports.KeyBuilderSS = void 0;
+exports.KeyBuilderSS = exports.METHOD_NAMES = void 0;
 var tslib_1 = require("tslib");
 var KeyBuilder_1 = require("./KeyBuilder");
-var TelemetryCacheInMemory_1 = require("./inMemory/TelemetryCacheInMemory");
-var METHOD_NAMES = {
+exports.METHOD_NAMES = {
     t: 'treatment',
     ts: 'treatments',
     tc: 'treatmentWithConfig',
@@ -41,10 +40,10 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     };
     /* Telemetry keys */
     KeyBuilderSS.prototype.buildLatencyKey = function (method, bucket) {
-        return this.latencyPrefix + "::" + this.versionablePrefix + "/" + METHOD_NAMES[method] + "/" + bucket;
+        return this.latencyPrefix + "::" + this.versionablePrefix + "/" + exports.METHOD_NAMES[method] + "/" + bucket;
     };
     KeyBuilderSS.prototype.buildExceptionKey = function (method) {
-        return this.exceptionPrefix + "::" + this.versionablePrefix + "/" + METHOD_NAMES[method];
+        return this.exceptionPrefix + "::" + this.versionablePrefix + "/" + exports.METHOD_NAMES[method];
     };
     KeyBuilderSS.prototype.buildInitKey = function () {
         return this.initPrefix + "::" + this.versionablePrefix;
@@ -52,41 +51,3 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     return KeyBuilderSS;
 }(KeyBuilder_1.KeyBuilder));
 exports.KeyBuilderSS = KeyBuilderSS;
-// Used by consumer methods of TelemetryCacheInRedis and TelemetryCachePluggable
-var REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce(function (acc, key) {
-    acc[METHOD_NAMES[key]] = key;
-    return acc;
-}, {});
-function parseMetadata(field) {
-    var parts = field.split('/');
-    if (parts.length !== 3)
-        return "invalid subsection count. Expected 3, got: " + parts.length;
-    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */;
-    return [JSON.stringify({ s: s, n: n, i: i })];
-}
-exports.parseMetadata = parseMetadata;
-function parseExceptionField(field) {
-    var parts = field.split('/');
-    if (parts.length !== 4)
-        return "invalid subsection count. Expected 4, got: " + parts.length;
-    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3];
-    var method = REVERSE_METHOD_NAMES[m];
-    if (!method)
-        return "unknown method '" + m + "'";
-    return [JSON.stringify({ s: s, n: n, i: i }), method];
-}
-exports.parseExceptionField = parseExceptionField;
-function parseLatencyField(field) {
-    var parts = field.split('/');
-    if (parts.length !== 5)
-        return "invalid subsection count. Expected 5, got: " + parts.length;
-    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3], b = parts[4];
-    var method = REVERSE_METHOD_NAMES[m];
-    if (!method)
-        return "unknown method '" + m + "'";
-    var bucket = parseInt(b);
-    if (isNaN(bucket) || bucket >= TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT)
-        return "invalid bucket. Expected a number between 0 and " + (TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT - 1) + ", got: " + b;
-    return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
-}
-exports.parseLatencyField = parseLatencyField;

package/cjs/storages/inLocalStorage/index.js

@@ -17,6 +17,7 @@ var constants_1 = require("./constants");
 var constants_2 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("../inMemory/TelemetryCacheInMemory");
 var UniqueKeysCacheInMemoryCS_1 = require("../inMemory/UniqueKeysCacheInMemoryCS");
+var key_1 = require("../../utils/key");
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -26,20 +27,23 @@ function InLocalStorage(options) {
     function InLocalStorageCSFactory(params) {
         // Fallback to InMemoryStorage if LocalStorage API is not available
         if (!(0, isLocalStorageAvailable_1.isLocalStorageAvailable)()) {
-            params.log.warn(constants_1.LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
+            params.settings.log.warn(constants_1.LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
         }
-        var log = params.log;
-        var keys = new KeyBuilderCS_1.KeyBuilderCS(prefix, params.matchingKey);
+        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+        var matchingKey = (0, key_1.getMatching)(settings.core.key);
+        var keys = new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - browser_1.DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
+        var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(log, keys, expirationTimestamp, __splitFiltersValidation);
+        var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys);
         return {
-            splits: new SplitsCacheInLocal_1.SplitsCacheInLocal(log, keys, expirationTimestamp, params.splitFiltersValidation),
-            segments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys),
-            impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(params.impressionsQueueSize),
-            impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
-            events: new EventsCacheInMemory_1.EventsCacheInMemory(params.eventsQueueSize),
-            telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : undefined,
-            uniqueKeys: params.impressionsMode === constants_2.NONE ? new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() : undefined,
+            splits: splits,
+            segments: segments,
+            impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize),
+            impressionCounts: impressionsMode !== constants_2.DEBUG ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
+            events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
+            telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
+            uniqueKeys: impressionsMode === constants_2.NONE ? new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() : undefined,
             destroy: function () {
                 var _a;
                 this.splits = new SplitsCacheInMemory_1.SplitsCacheInMemory();

package/cjs/storages/inMemory/InMemoryStorage.js

@@ -15,14 +15,17 @@ var UniqueKeysCacheInMemory_1 = require("./UniqueKeysCacheInMemory");
  * @param params parameters required by EventsCacheSync
  */
 function InMemoryStorageFactory(params) {
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
+    var splits = new SplitsCacheInMemory_1.SplitsCacheInMemory();
+    var segments = new SegmentsCacheInMemory_1.SegmentsCacheInMemory();
     return {
-        splits: new SplitsCacheInMemory_1.SplitsCacheInMemory(),
-        segments: new SegmentsCacheInMemory_1.SegmentsCacheInMemory(),
-        impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.impressionsMode !== constants_1.DEBUG ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
-        events: new EventsCacheInMemory_1.EventsCacheInMemory(params.eventsQueueSize),
-        telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : undefined,
-        uniqueKeys: params.impressionsMode === constants_1.NONE ? new UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory() : undefined,
+        splits: splits,
+        segments: segments,
+        impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize),
+        impressionCounts: impressionsMode !== constants_1.DEBUG ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
+        events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
+        telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
+        uniqueKeys: impressionsMode === constants_1.NONE ? new UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory() : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
             var _a;

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -15,14 +15,17 @@ var UniqueKeysCacheInMemoryCS_1 = require("./UniqueKeysCacheInMemoryCS");
  * @param params parameters required by EventsCacheSync
  */
 function InMemoryStorageCSFactory(params) {
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
+    var splits = new SplitsCacheInMemory_1.SplitsCacheInMemory();
+    var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
     return {
-        splits: new SplitsCacheInMemory_1.SplitsCacheInMemory(),
-        segments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
-        impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.impressionsMode !== constants_1.DEBUG ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
-        events: new EventsCacheInMemory_1.EventsCacheInMemory(params.eventsQueueSize),
-        telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : undefined,
-        uniqueKeys: params.impressionsMode === constants_1.NONE ? new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() : undefined,
+        splits: splits,
+        segments: segments,
+        impressions: new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize),
+        impressionCounts: impressionsMode !== constants_1.DEBUG ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
+        events: new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize),
+        telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
+        uniqueKeys: impressionsMode === constants_1.NONE ? new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
             var _a;

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -17,30 +17,56 @@ var ACCEPTANCE_RANGE = 0.001;
  * Record telemetry if mode is not localhost.
  * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-function shouldRecordTelemetry(params) {
-    return params.mode !== constants_1.LOCALHOST_MODE && (params.matchingKey === undefined || Math.random() <= ACCEPTANCE_RANGE);
+function shouldRecordTelemetry(_a) {
+    var settings = _a.settings;
+    return settings.mode !== constants_1.LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 exports.shouldRecordTelemetry = shouldRecordTelemetry;
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory() {
+    function TelemetryCacheInMemory(splits, segments) {
+        this.splits = splits;
+        this.segments = segments;
+        // isEmpty flag
+        this.e = true;
         this.notReadyUsage = 0;
+        /** Usage stats */
         this.impressionStats = [0, 0, 0];
         this.eventStats = [0, 0];
-        // @ts-expect-error
         this.lastSync = {};
-        // @ts-expect-error
         this.httpErrors = {};
-        // @ts-expect-error
         this.httpLatencies = {};
         this.authRejections = 0;
         this.tokenRefreshes = 0;
         this.streamingEvents = [];
         this.tags = [];
-        // @ts-expect-error
         this.exceptions = {};
-        // @ts-expect-error
         this.latencies = {};
     }
+    TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
+    TelemetryCacheInMemory.prototype.clear = function () { };
+    TelemetryCacheInMemory.prototype.pop = function () {
+        this.e = true;
+        return {
+            lS: this.getLastSynchronization(),
+            mL: this.popLatencies(),
+            mE: this.popExceptions(),
+            hE: this.popHttpErrors(),
+            hL: this.popHttpLatencies(),
+            tR: this.popTokenRefreshes(),
+            aR: this.popAuthRejections(),
+            iQ: this.getImpressionStats(constants_1.QUEUED),
+            iDe: this.getImpressionStats(constants_1.DEDUPED),
+            iDr: this.getImpressionStats(constants_1.DROPPED),
+            spC: this.splits && this.splits.getSplitNames().length,
+            seC: this.segments && this.segments.getRegisteredSegments().length,
+            skC: this.segments && this.segments.getKeysCount(),
+            sL: this.getSessionLength(),
+            eQ: this.getEventStats(constants_1.QUEUED),
+            eD: this.getEventStats(constants_1.DROPPED),
+            sE: this.popStreamingEvents(),
+            t: this.popTags(),
+        };
+    };
     TelemetryCacheInMemory.prototype.getTimeUntilReady = function () {
         return this.timeUntilReady;
     };
@@ -64,44 +90,41 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.recordImpressionStats = function (type, count) {
         this.impressionStats[type] += count;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.getEventStats = function (type) {
         return this.eventStats[type];
     };
     TelemetryCacheInMemory.prototype.recordEventStats = function (type, count) {
         this.eventStats[type] += count;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.getLastSynchronization = function () {
         return this.lastSync;
     };
     TelemetryCacheInMemory.prototype.recordSuccessfulSync = function (resource, timeMs) {
         this.lastSync[resource] = timeMs;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popHttpErrors = function () {
-        var result = this.httpErrors; // @ts-expect-error
+        var result = this.httpErrors;
         this.httpErrors = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordHttpError = function (resource, status) {
-        if (!this.httpErrors[resource])
-            this.httpErrors[resource] = {};
-        if (!this.httpErrors[resource][status]) {
-            this.httpErrors[resource][status] = 1;
-        }
-        else {
-            this.httpErrors[resource][status]++;
-        }
+        var statusErrors = (this.httpErrors[resource] = this.httpErrors[resource] || {});
+        statusErrors[status] = (statusErrors[status] || 0) + 1;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popHttpLatencies = function () {
-        var result = this.httpLatencies; // @ts-expect-error
+        var result = this.httpLatencies;
         this.httpLatencies = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordHttpLatency = function (resource, latencyMs) {
-        if (!this.httpLatencies[resource]) {
-            this.httpLatencies[resource] = newBuckets();
-        }
-        this.httpLatencies[resource][(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
+        var latencyBuckets = (this.httpLatencies[resource] = this.httpLatencies[resource] || newBuckets());
+        latencyBuckets[(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popAuthRejections = function () {
         var result = this.authRejections;
@@ -110,6 +133,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.recordAuthRejections = function () {
         this.authRejections++;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popTokenRefreshes = function () {
         var result = this.tokenRefreshes;
@@ -118,6 +142,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.recordTokenRefreshes = function () {
         this.tokenRefreshes++;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popStreamingEvents = function () {
         return this.streamingEvents.splice(0);
@@ -126,6 +151,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         if (this.streamingEvents.length < MAX_STREAMING_EVENTS) {
             this.streamingEvents.push(streamingEvent);
         }
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popTags = function () {
         return this.tags.splice(0);
@@ -134,36 +160,33 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         if (this.tags.length < MAX_TAGS) {
             this.tags.push(tag);
         }
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.getSessionLength = function () {
         return this.sessionLength;
     };
     TelemetryCacheInMemory.prototype.recordSessionLength = function (ms) {
         this.sessionLength = ms;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popExceptions = function () {
-        var result = this.exceptions; // @ts-expect-error
+        var result = this.exceptions;
         this.exceptions = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordException = function (method) {
-        if (!this.exceptions[method]) {
-            this.exceptions[method] = 1;
-        }
-        else {
-            this.exceptions[method]++;
-        }
+        this.exceptions[method] = (this.exceptions[method] || 0) + 1;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popLatencies = function () {
-        var result = this.latencies; // @ts-expect-error
+        var result = this.latencies;
         this.latencies = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordLatency = function (method, latencyMs) {
-        if (!this.latencies[method]) {
-            this.latencies[method] = newBuckets();
-        }
-        this.latencies[method][(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
+        var latencyBuckets = (this.latencies[method] = this.latencies[method] || newBuckets());
+        latencyBuckets[(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
+        this.e = false;
     };
     return TelemetryCacheInMemory;
 }());

package/cjs/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -54,7 +54,7 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
             if (!Object.keys(counts).length)
                 return undefined;
             _this.redis.del(_this.key).catch(function () { });
-            var impressionsCount = { pf: [] };
+            var pf = [];
             (0, lang_1.forOwn)(counts, function (count, key) {
                 var nameAndTime = key.split('::');
                 if (nameAndTime.length !== 2) {
@@ -71,13 +71,13 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
                     _this.log.error(constants_1.LOG_PREFIX + "Error parsing raw count " + count);
                     return;
                 }
-                impressionsCount.pf.push({
+                pf.push({
                     f: nameAndTime[0],
                     m: timeFrame,
                     rc: rawCount,
                 });
             });
-            return impressionsCount;
+            return { pf: pf };
         });
     };
     return 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

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelemetryCacheInRedis = 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 utils_1 = require("../utils");
 var TelemetryCacheInRedis = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses Redis as storage.
@@ -44,7 +44,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         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, KeyBuilderSS_1.parseLatencyField)(field);
+                var parsedField = (0, utils_1.parseLatencyField)(field);
                 if ((0, lang_1.isString)(parsedField)) {
                     _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
                     return;
@@ -81,7 +81,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         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, KeyBuilderSS_1.parseExceptionField)(field);
+                var parsedField = (0, utils_1.parseExceptionField)(field);
                 if ((0, lang_1.isString)(parsedField)) {
                     _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
                     return;
@@ -114,7 +114,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         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, KeyBuilderSS_1.parseMetadata)(field);
+                var parsedField = (0, utils_1.parseMetadata)(field);
                 if ((0, lang_1.isString)(parsedField)) {
                     _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
                     return;

package/cjs/storages/inRedis/index.js

@@ -12,6 +12,7 @@ var constants_1 = require("../../utils/constants");
 var TelemetryCacheInRedis_1 = require("./TelemetryCacheInRedis");
 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,8 +20,9 @@ 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);

package/cjs/storages/pluggable/ImpressionCountsCachePluggable.js

@@ -46,7 +46,7 @@ var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
             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 impressionsCount = { pf: [] };
+                var pf = [];
                 for (var i = 0; i < keys.length; i++) {
                     var key = keys[i];
                     var count = counts[i];
@@ -66,13 +66,13 @@ var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
                         _this.log.error(constants_2.LOG_PREFIX + "Error parsing raw count " + count);
                         continue;
                     }
-                    impressionsCount.pf.push({
+                    pf.push({
                         f: keyFeatureNameAndTime[1],
                         m: timeFrame,
                         rc: rawCount,
                     });
                 }
-                return impressionsCount;
+                return { pf: pf };
             }) : undefined;
         });
     };