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

package/CHANGES.txt

@@ -1,5 +1,8 @@
-1.6.2 (September XXX, 2022)
+1.7.0 (October 4, 2022)
+- Added a new impressions mode for the SDK called NONE, to be used in factory when there is no desire to capture impressions on an SDK factory to feed Split's analytics engine. Running NONE mode, the SDK will only capture unique keys evaluated for a particular feature flag instead of full blown impressions.
+- Updated SDK telemetry to support pluggable storage, partial consumer mode, and synchronizer.
 - Updated storage implementations to improve the performance of split evaluations (i.e., `getTreatment(s)` method calls) when using the default storage in memory.
+- Updated evaluation flow to avoid unnecessarily storage calls when the SDK is not ready.
 
 1.6.1 (July 22, 2022)
 - Updated GoogleAnalyticsToSplit integration to validate `autoRequire` config parameter and avoid some wrong warning logs when mapping GA hit fields to Split event properties.

package/cjs/evaluator/index.js

@@ -19,21 +19,21 @@ function treatmentsException(splitNames) {
     return evaluations;
 }
 function evaluateFeature(log, key, splitName, attributes, storage) {
-    var stringifiedSplit;
+    var parsedSplit;
     try {
-        stringifiedSplit = storage.splits.getSplit(splitName);
+        parsedSplit = storage.splits.getSplit(splitName);
     }
     catch (e) {
         // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
         return treatmentException;
     }
-    if ((0, thenable_1.thenable)(stringifiedSplit)) {
-        return stringifiedSplit.then(function (result) { return getEvaluation(log, result, key, attributes, storage); }).catch(
+    if ((0, thenable_1.thenable)(parsedSplit)) {
+        return parsedSplit.then(function (split) { return getEvaluation(log, split, key, attributes, storage); }).catch(
         // Exception on async `getSplit` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         function () { return treatmentException; });
     }
-    return getEvaluation(log, stringifiedSplit, key, attributes, storage);
+    return getEvaluation(log, parsedSplit, key, attributes, storage);
 }
 exports.evaluateFeature = evaluateFeature;
 function evaluateFeatures(log, key, splitNames, attributes, storage) {

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/sdkClient/client.js

@@ -9,6 +9,15 @@ var trafficTypeExistance_1 = require("../utils/inputValidation/trafficTypeExista
 var labels_1 = require("../utils/labels");
 var constants_1 = require("../utils/constants");
 var constants_2 = require("../logger/constants");
+var utils_1 = require("../trackers/impressionObserver/utils");
+var treatmentNotReady = { treatment: constants_1.CONTROL, label: labels_1.SDK_NOT_READY };
+function treatmentsNotReady(splitNames) {
+    var evaluations = {};
+    splitNames.forEach(function (splitName) {
+        evaluations[splitName] = treatmentNotReady;
+    });
+    return evaluations;
+}
 /**
  * Creator of base client with getTreatments and track methods.
  */
@@ -25,7 +34,11 @@ function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].label);
             return treatment;
         };
-        var evaluation = (0, evaluator_1.evaluateFeature)(log, key, splitName, attributes, storage);
+        var evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+            (0, evaluator_1.evaluateFeature)(log, key, splitName, attributes, storage) :
+            (0, utils_1.isStorageSync)(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+                treatmentNotReady :
+                Promise.resolve(treatmentNotReady); // Promisify if async
         return (0, thenable_1.thenable)(evaluation) ? evaluation.then(function (res) { return wrapUp(res); }) : wrapUp(evaluation);
     }
     function getTreatmentWithConfig(key, splitName, attributes) {
@@ -44,7 +57,11 @@ function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].label);
             return treatments;
         };
-        var evaluations = (0, evaluator_1.evaluateFeatures)(log, key, splitNames, attributes, storage);
+        var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+            (0, evaluator_1.evaluateFeatures)(log, key, splitNames, attributes, storage) :
+            (0, utils_1.isStorageSync)(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
+                treatmentsNotReady(splitNames) :
+                Promise.resolve(treatmentsNotReady(splitNames)); // Promisify if async
         return (0, thenable_1.thenable)(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
     }
     function getTreatmentsWithConfig(key, splitNames, attributes) {
@@ -52,13 +69,8 @@ function clientFactory(params) {
     }
     // Internal function
     function processEvaluation(evaluation, splitName, key, attributes, withConfig, invokingMethodName, queue) {
-        var isSdkReady = readinessManager.isReady() || readinessManager.isReadyFromCache();
         var matchingKey = (0, key_1.getMatching)(key);
         var bucketingKey = (0, key_1.getBucketing)(key);
-        // If the SDK was not ready, treatment may be incorrect due to having Splits but not segments data.
-        if (!isSdkReady) {
-            evaluation = { treatment: constants_1.CONTROL, label: labels_1.SDK_NOT_READY };
-        }
         var treatment = evaluation.treatment, label = evaluation.label, changeNumber = evaluation.changeNumber, _a = evaluation.config, config = _a === void 0 ? null : _a;
         log.info(constants_2.IMPRESSION, [splitName, matchingKey, treatment, label]);
         if ((0, splitExistance_1.validateSplitExistance)(log, readinessManager, splitName, label, invokingMethodName)) {

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,44 +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,
-        uniqueKeysCacheSize: settings.scheduler.uniqueKeysCacheSize,
-        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;
@@ -95,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/services/splitApi.js

@@ -110,13 +110,13 @@ function splitApiFactory(settings, platform, telemetryTracker) {
             var url = urls.telemetry + "/v1/keys/ss";
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY));
         },
-        postMetricsConfig: function (body) {
+        postMetricsConfig: function (body, headers) {
             var url = urls.telemetry + "/v1/metrics/config";
-            return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(constants_1.TELEMETRY), true);
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), true);
         },
-        postMetricsUsage: function (body) {
+        postMetricsUsage: function (body, headers) {
             var url = urls.telemetry + "/v1/metrics/usage";
-            return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(constants_1.TELEMETRY), true);
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), true);
         }
     };
 }

package/cjs/storages/AbstractSplitsCacheAsync.js

@@ -28,7 +28,7 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
      * @param {string} name
      * @param {string} defaultTreatment
      * @param {number} changeNumber
-     * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated,
+     * @returns {Promise} a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
      * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
      * The promise will never be rejected.
      */

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -43,7 +43,7 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
      * @param {string} name
      * @param {string} defaultTreatment
      * @param {number} changeNumber
-     * @returns {Promise} a promise that is resolved once the split kill is performed. The fulfillment value is a boolean: `true` if the kill success updating the split or `false` if no split is updated,
+     * @returns {boolean} `true` if the operation successed updating the split, or `false` if no split is updated,
      * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
      */
     AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {

package/cjs/storages/KeyBuilderSS.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyBuilderSS = void 0;
+exports.KeyBuilderSS = exports.METHOD_NAMES = void 0;
 var tslib_1 = require("tslib");
 var KeyBuilder_1 = require("./KeyBuilder");
-var methodNames = {
+exports.METHOD_NAMES = {
     t: 'treatment',
     ts: 'treatments',
     tc: 'treatmentWithConfig',
@@ -14,7 +14,10 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(KeyBuilderSS, _super);
     function KeyBuilderSS(prefix, metadata) {
         var _this = _super.call(this, prefix) || this;
-        _this.metadata = metadata;
+        _this.latencyPrefix = _this.prefix + ".telemetry.latencies";
+        _this.exceptionPrefix = _this.prefix + ".telemetry.exceptions";
+        _this.initPrefix = _this.prefix + ".telemetry.init";
+        _this.versionablePrefix = metadata.s + "/" + metadata.n + "/" + metadata.i;
         return _this;
     }
     KeyBuilderSS.prototype.buildRegisteredSegmentsKey = function () {
@@ -37,16 +40,13 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     };
     /* Telemetry keys */
     KeyBuilderSS.prototype.buildLatencyKey = function (method, bucket) {
-        return this.prefix + ".telemetry.latencies::" + this.buildVersionablePrefix() + "/" + methodNames[method] + "/" + bucket;
+        return this.latencyPrefix + "::" + this.versionablePrefix + "/" + exports.METHOD_NAMES[method] + "/" + bucket;
     };
     KeyBuilderSS.prototype.buildExceptionKey = function (method) {
-        return this.prefix + ".telemetry.exceptions::" + this.buildVersionablePrefix() + "/" + methodNames[method];
+        return this.exceptionPrefix + "::" + this.versionablePrefix + "/" + exports.METHOD_NAMES[method];
     };
     KeyBuilderSS.prototype.buildInitKey = function () {
-        return this.prefix + ".telemetry.init::" + this.buildVersionablePrefix();
-    };
-    KeyBuilderSS.prototype.buildVersionablePrefix = function () {
-        return this.metadata.s + "/" + this.metadata.n + "/" + this.metadata.i;
+        return this.initPrefix + "::" + this.versionablePrefix;
     };
     return KeyBuilderSS;
 }(KeyBuilder_1.KeyBuilder));

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -203,7 +203,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-     * Clean operation (clear) also updates `lastUpdated` timestamp with current time.
      *
      * @param {number | undefined} expirationTimestamp if the value is not a number, data will not be cleaned
      */

package/cjs/storages/inLocalStorage/index.js

@@ -16,7 +16,8 @@ var InMemoryStorageCS_1 = require("../inMemory/InMemoryStorageCS");
 var constants_1 = require("./constants");
 var constants_2 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("../inMemory/TelemetryCacheInMemory");
-var uniqueKeysCacheInMemoryCS_1 = require("../inMemory/uniqueKeysCacheInMemoryCS");
+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: params.mode !== constants_2.LOCALHOST_MODE && (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)() ? 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

@@ -8,21 +8,24 @@ var EventsCacheInMemory_1 = require("./EventsCacheInMemory");
 var ImpressionCountsCacheInMemory_1 = require("./ImpressionCountsCacheInMemory");
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("./TelemetryCacheInMemory");
-var uniqueKeysCacheInMemory_1 = require("./uniqueKeysCacheInMemory");
+var UniqueKeysCacheInMemory_1 = require("./UniqueKeysCacheInMemory");
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
  * @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: params.mode !== constants_1.LOCALHOST_MODE ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : undefined,
-        uniqueKeys: params.impressionsMode === constants_1.NONE ? new uniqueKeysCacheInMemory_1.UniqueKeysCacheInMemory(params.uniqueKeysCacheSize) : 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

@@ -8,21 +8,24 @@ var EventsCacheInMemory_1 = require("./EventsCacheInMemory");
 var ImpressionCountsCacheInMemory_1 = require("./ImpressionCountsCacheInMemory");
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("./TelemetryCacheInMemory");
-var uniqueKeysCacheInMemoryCS_1 = require("./uniqueKeysCacheInMemoryCS");
+var UniqueKeysCacheInMemoryCS_1 = require("./UniqueKeysCacheInMemoryCS");
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
  * @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: params.mode !== constants_1.LOCALHOST_MODE && (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)() ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory() : undefined,
-        uniqueKeys: params.impressionsMode === constants_1.NONE ? new uniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS(params.uniqueKeysCacheSize) : 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

@@ -1,41 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelemetryCacheInMemory = exports.shouldRecordTelemetry = void 0;
+exports.TelemetryCacheInMemory = exports.shouldRecordTelemetry = exports.newBuckets = exports.MAX_LATENCY_BUCKET_COUNT = void 0;
+var constants_1 = require("../../utils/constants");
 var findLatencyIndex_1 = require("../findLatencyIndex");
 var MAX_STREAMING_EVENTS = 20;
 var MAX_TAGS = 10;
+exports.MAX_LATENCY_BUCKET_COUNT = 23;
 function newBuckets() {
-    // MAX_LATENCY_BUCKET_COUNT (length) is 23;
+    // MAX_LATENCY_BUCKET_COUNT (length) is 23
+    // Not using Array.fill for old browsers compatibility
     return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
 }
+exports.newBuckets = newBuckets;
 var ACCEPTANCE_RANGE = 0.001;
 /**
- * Used on client-side. 0.1% of instances will track telemetry
+ * Record telemetry if mode is not localhost.
+ * All factory instances track telemetry on server-side, and 0.1% on client-side.
  */
-function shouldRecordTelemetry() {
-    return 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;
     };
@@ -59,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;
@@ -105,6 +133,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.recordAuthRejections = function () {
         this.authRejections++;
+        this.e = false;
     };
     TelemetryCacheInMemory.prototype.popTokenRefreshes = function () {
         var result = this.tokenRefreshes;
@@ -113,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);
@@ -121,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);
@@ -129,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;
 }());