@splitsoftware/splitio-commons 1.6.2-rc.11 → 1.6.2-rc.13

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/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/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 metadataBuilder_1 = require("../metadataBuilder");
 /**
  * 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, metadataBuilder_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/index.js

@@ -20,6 +20,7 @@ var ImpressionCountsCachePluggable_1 = require("./ImpressionCountsCachePluggable
 var UniqueKeysCachePluggable_1 = require("./UniqueKeysCachePluggable");
 var UniqueKeysCacheInMemory_1 = require("../inMemory/UniqueKeysCacheInMemory");
 var UniqueKeysCacheInMemoryCS_1 = require("../inMemory/UniqueKeysCacheInMemoryCS");
+var metadataBuilder_1 = require("../metadataBuilder");
 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.';
 /**
@@ -52,7 +53,8 @@ function PluggableStorage(options) {
     validatePluggableStorageOptions(options);
     var prefix = (0, KeyBuilder_1.validatePrefix)(options.prefix);
     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 onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, mode = _a.mode, impressionsMode = _a.sync.impressionsMode, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize;
+        var metadata = (0, metadataBuilder_1.metadataBuilder)(settings);
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
         var wrapper = (0, wrapperAdapter_1.wrapperAdapter)(log, options.wrapper);
         var isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
@@ -69,19 +71,21 @@ function PluggableStorage(options) {
             undefined;
         var uniqueKeysCache = impressionsMode === constants_1.NONE || isSyncronizer ?
             isPartialConsumer ?
-                matchingKey === undefined ? new UniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS() :
+                settings.core.key === 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
         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 (telemetry && telemetry.recordConfig && !isSyncronizer)
-                telemetry.recordConfig();
+            // Start periodic flush of async storages if not running synchronizer (producer mode)
+            if (!isSyncronizer) {
+                if (impressionCountsCache && impressionCountsCache.start)
+                    impressionCountsCache.start();
+                if (uniqueKeysCache && uniqueKeysCache.start)
+                    uniqueKeysCache.start();
+                if (telemetry && telemetry.recordConfig)
+                    telemetry.recordConfig();
+            }
         }).catch(function (e) {
             e = e || new Error('Error connecting wrapper');
             onReadyCb(e);
@@ -95,9 +99,9 @@ function PluggableStorage(options) {
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable_1.EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
             telemetry: telemetry,
             uniqueKeys: uniqueKeysCache,
-            // Disconnect the underlying storage
+            // Stop periodic flush and disconnect the underlying storage
             destroy: function () {
-                return Promise.all([
+                return Promise.all(isSyncronizer ? [] : [
                     impressionCountsCache && impressionCountsCache.stop && impressionCountsCache.stop(),
                     uniqueKeysCache && uniqueKeysCache.stop && uniqueKeysCache.stop(),
                 ]).then(function () { return wrapper.disconnect(); });

package/cjs/sync/submitters/submitterManager.js

@@ -15,7 +15,7 @@ function submitterManagerFactory(params) {
     if (impressionCountsSubmitter)
         submitters.push(impressionCountsSubmitter);
     var telemetrySubmitter = (0, telemetrySubmitter_1.telemetrySubmitterFactory)(params);
-    if (params.uniqueKeysTracker)
+    if (params.storage.uniqueKeys)
         submitters.push((0, uniqueKeysSubmitter_1.uniqueKeysSubmitterFactory)(params));
     return {
         // `onlyTelemetry` true if SDK is created with userConsent not GRANTED

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -1,7 +1,7 @@
 "use strict";
 var _a, _b, _c;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.telemetrySubmitterFactory = exports.telemetryCacheConfigAdapter = exports.getTelemetryConfigStats = exports.telemetryCacheStatsAdapter = void 0;
+exports.telemetrySubmitterFactory = exports.telemetryCacheConfigAdapter = exports.getTelemetryConfigStats = void 0;
 var submitter_1 = require("./submitter");
 var constants_1 = require("../../utils/constants");
 var constants_2 = require("../../readiness/constants");
@@ -9,40 +9,6 @@ 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.
- */
-function telemetryCacheStatsAdapter(telemetry, splits, segments) {
-    return {
-        isEmpty: function () { return false; },
-        clear: function () { },
-        // @TODO consider moving inside telemetry cache for code size reduction
-        pop: function () {
-            return {
-                lS: telemetry.getLastSynchronization(),
-                mL: telemetry.popLatencies(),
-                mE: telemetry.popExceptions(),
-                hE: telemetry.popHttpErrors(),
-                hL: telemetry.popHttpLatencies(),
-                tR: telemetry.popTokenRefreshes(),
-                aR: telemetry.popAuthRejections(),
-                iQ: telemetry.getImpressionStats(constants_1.QUEUED),
-                iDe: telemetry.getImpressionStats(constants_1.DEDUPED),
-                iDr: telemetry.getImpressionStats(constants_1.DROPPED),
-                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),
-                sE: telemetry.popStreamingEvents(),
-                t: telemetry.popTags(),
-            };
-        }
-    };
-}
-exports.telemetryCacheStatsAdapter = telemetryCacheStatsAdapter;
 var OPERATION_MODE_MAP = (_a = {},
     _a[constants_1.STANDALONE_MODE] = constants_1.STANDALONE_ENUM,
     _a[constants_1.CONSUMER_MODE] = constants_1.CONSUMER_ENUM,
@@ -122,14 +88,12 @@ exports.telemetryCacheConfigAdapter = telemetryCacheConfigAdapter;
  * Submitter that periodically posts telemetry data
  */
 function telemetrySubmitterFactory(params) {
-    var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry, now = params.platform.now;
+    var telemetry = params.storage.telemetry, now = params.platform.now;
     if (!telemetry || !now)
         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 settings = params.settings, _a = params.settings, log = _a.log, telemetryRefreshRate = _a.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, 
-    // @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);
+    var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, splitApi.postMetricsUsage, telemetry, telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(constants_2.SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());
     });

package/cjs/trackers/impressionObserver/utils.js

@@ -1,23 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStorageSync = exports.shouldBeOptimized = exports.shouldAddPt = void 0;
+exports.isStorageSync = void 0;
 var constants_1 = require("../../utils/constants");
-/**
- * Checks if impressions previous time should be added or not.
- */
-function shouldAddPt(settings) {
-    return [constants_1.PRODUCER_MODE, constants_1.STANDALONE_MODE, constants_1.CONSUMER_PARTIAL_MODE].indexOf(settings.mode) > -1 ? true : false;
-}
-exports.shouldAddPt = shouldAddPt;
-/**
- * Checks if it should dedupe impressions or not.
- */
-function shouldBeOptimized(settings) {
-    if (!shouldAddPt(settings))
-        return false;
-    return settings.sync.impressionsMode === constants_1.OPTIMIZED ? true : false;
-}
-exports.shouldBeOptimized = shouldBeOptimized;
 /**
  * Storage is async if mode is consumer or partial consumer
  */

package/cjs/trackers/uniqueKeysTracker.js

@@ -10,7 +10,7 @@ var noopFilterAdapter = {
 /**
  * Trackes uniques keys
  * Unique Keys Tracker will be in charge of checking if the MTK was already sent to the BE in the last period
- *  or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
+ * or schedule to be sent; if not it will be added in an internal cache and sent in the next post.
  *
  * @param log Logger instance
  * @param uniqueKeysCache cache to save unique keys

package/cjs/utils/settingsValidation/index.js

@@ -132,8 +132,8 @@ function settingsValidation(config, validationParams) {
     if (storage)
         withDefaults.storage = storage(withDefaults);
     // Validate key and TT (for client-side)
+    var maybeKey = withDefaults.core.key;
     if (validationParams.acceptKey) {
-        var maybeKey = withDefaults.core.key;
         // Although `key` is required in client-side, it can be omitted in LOCALHOST mode. In that case, the value `localhost_key` is used.
         if (withDefaults.mode === constants_1.LOCALHOST_MODE && maybeKey === undefined) {
             withDefaults.core.key = 'localhost_key';
@@ -151,6 +151,12 @@ function settingsValidation(config, validationParams) {
             }
         }
     }
+    else {
+        // On server-side, key is undefined and used to distinguish from client-side
+        if (maybeKey !== undefined)
+            log.warn('Provided `key` is ignored in server-side SDK.'); // @ts-ignore
+        withDefaults.core.key = undefined;
+    }
     // Current ip/hostname information
     // @ts-ignore, modify readonly prop
     withDefaults.runtime = runtime(withDefaults);