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

package/cjs/utils/settingsValidation/index.js

@@ -34,8 +34,6 @@ exports.base = {
         telemetryRefreshRate: 3600,
         // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
         impressionsRefreshRate: 300,
-        // publish unique Keys each 900 sec (15 min) 
-        uniqueKeysRefreshRate: 900,
         // fetch offline changes each 15 sec
         offlineRefreshRate: 15,
         // publish events every 60 seconds after the first flush
@@ -114,7 +112,6 @@ function settingsValidation(config, validationParams) {
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
-    scheduler.uniqueKeysRefreshRate = fromSecondsToMillis(scheduler.uniqueKeysRefreshRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
     // Default impressionsRefreshRate for DEBUG mode is 60 secs
     if ((0, lang_1.get)(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === constants_1.DEBUG)
@@ -135,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';
@@ -154,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);

package/esm/evaluator/index.js

@@ -15,21 +15,21 @@ function treatmentsException(splitNames) {
     return evaluations;
 }
 export 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 (thenable(stringifiedSplit)) {
-        return stringifiedSplit.then(function (result) { return getEvaluation(log, result, key, attributes, storage); }).catch(
+    if (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);
 }
 export function evaluateFeatures(log, key, splitNames, attributes, storage) {
     var parsedSplits;

package/esm/listeners/browser.js

@@ -4,7 +4,6 @@ import { OPTIMIZED, DEBUG, NONE } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
-import { telemetryCacheStatsAdapter } from '../sync/submitters/telemetrySubmitter';
 var VISIBILITYCHANGE_EVENT = 'visibilitychange';
 var PAGEHIDE_EVENT = 'pagehide';
 var UNLOAD_EVENT = 'unload';
@@ -68,25 +67,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 (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 === OPTIMIZED ? OPTIMIZED : sim === DEBUG ? DEBUG : 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, fromImpressionCountsCollector);
+                this._flushData(events + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, 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 = 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
@@ -100,7 +99,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/esm/sdkClient/client.js

@@ -6,6 +6,15 @@ import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTy
 import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK } from '../utils/constants';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
+import { isStorageSync } from '../trackers/impressionObserver/utils';
+var treatmentNotReady = { treatment: CONTROL, label: 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.
  */
@@ -22,7 +31,11 @@ export function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].label);
             return treatment;
         };
-        var evaluation = evaluateFeature(log, key, splitName, attributes, storage);
+        var evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+            evaluateFeature(log, key, splitName, attributes, storage) :
+            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 thenable(evaluation) ? evaluation.then(function (res) { return wrapUp(res); }) : wrapUp(evaluation);
     }
     function getTreatmentWithConfig(key, splitName, attributes) {
@@ -41,7 +54,11 @@ export function clientFactory(params) {
             stopTelemetryTracker(queue[0] && queue[0].label);
             return treatments;
         };
-        var evaluations = evaluateFeatures(log, key, splitNames, attributes, storage);
+        var evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
+            evaluateFeatures(log, key, splitNames, attributes, storage) :
+            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 thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
     }
     function getTreatmentsWithConfig(key, splitNames, attributes) {
@@ -49,13 +66,8 @@ export function clientFactory(params) {
     }
     // Internal function
     function processEvaluation(evaluation, splitName, key, attributes, withConfig, invokingMethodName, queue) {
-        var isSdkReady = readinessManager.isReady() || readinessManager.isReadyFromCache();
         var matchingKey = getMatching(key);
         var bucketingKey = getBucketing(key);
-        // If the SDK was not ready, treatment may be incorrect due to having Splits but not segments data.
-        if (!isSdkReady) {
-            evaluation = { treatment: CONTROL, label: SDK_NOT_READY };
-        }
         var treatment = evaluation.treatment, label = evaluation.label, changeNumber = evaluation.changeNumber, _a = evaluation.config, config = _a === void 0 ? null : _a;
         log.info(IMPRESSION, [splitName, matchingKey, treatment, label]);
         if (validateSplitExistance(log, readinessManager, splitName, label, invokingMethodName)) {

package/esm/sdkFactory/index.js

@@ -2,12 +2,9 @@ import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
 import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import { getMatching } from '../utils/key';
-import { shouldBeOptimized } from '../trackers/impressionObserver/utils';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { metadataBuilder } from '../storages/metadataBuilder';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
@@ -20,44 +17,29 @@ import { NONE, OPTIMIZED } from '../utils/constants';
  */
 export 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.
     validateAndTrackApiKey(log, settings.core.authorizationKey);
     var sdkReadinessManager = 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: shouldBeOptimized(settings),
-        // ATM, only used by InLocalStorage
-        matchingKey: 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(SDK_SPLITS_ARRIVED);
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         },
-        metadata: metadataBuilder(settings),
-        log: log
-    };
-    var storage = storageFactory(storageFactoryParams);
+    });
     // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
     var observer = impressionsObserverFactory();
-    var uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory()) : undefined;
+    var uniqueKeysTracker = impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory()) : undefined;
     var strategy;
-    switch (storageFactoryParams.impressionsMode) {
+    switch (impressionsMode) {
         case OPTIMIZED:
             strategy = strategyOptimizedFactory(observer, storage.impressionCounts);
             break;
@@ -92,7 +74,7 @@ export function sdkFactory(params) {
             return managerInstance;
         },
         // Logger wrapper API
-        Logger: createLoggerAPI(settings.log),
+        Logger: createLoggerAPI(log),
         settings: settings,
     }, extraProps && extraProps(ctx));
 }

package/esm/services/splitApi.js

@@ -107,13 +107,13 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             var url = urls.telemetry + "/v1/keys/ss";
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
         },
-        postMetricsConfig: function (body) {
+        postMetricsConfig: function (body, headers) {
             var url = urls.telemetry + "/v1/metrics/config";
-            return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(TELEMETRY), true);
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(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(TELEMETRY), true);
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
         }
     };
 }

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -25,7 +25,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/esm/storages/AbstractSplitsCacheSync.js

@@ -40,7 +40,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/esm/storages/KeyBuilderSS.js

@@ -1,6 +1,6 @@
 import { __extends } from "tslib";
 import { KeyBuilder } from './KeyBuilder';
-var methodNames = {
+export var METHOD_NAMES = {
     t: 'treatment',
     ts: 'treatments',
     tc: 'treatmentWithConfig',
@@ -11,7 +11,10 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     __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 () {
@@ -34,16 +37,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 + "/" + METHOD_NAMES[method] + "/" + bucket;
     };
     KeyBuilderSS.prototype.buildExceptionKey = function (method) {
-        return this.prefix + ".telemetry.exceptions::" + this.buildVersionablePrefix() + "/" + methodNames[method];
+        return this.exceptionPrefix + "::" + this.versionablePrefix + "/" + 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));

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -200,7 +200,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/esm/storages/inLocalStorage/index.js

@@ -11,9 +11,10 @@ import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
-import { LOCALHOST_MODE, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from '../inMemory/uniqueKeysCacheInMemoryCS';
+import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
+import { getMatching } from '../../utils/key';
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -23,20 +24,23 @@ export function InLocalStorage(options) {
     function InLocalStorageCSFactory(params) {
         // Fallback to InMemoryStorage if LocalStorage API is not available
         if (!isLocalStorageAvailable()) {
-            params.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
+            params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return InMemoryStorageCSFactory(params);
         }
-        var log = params.log;
-        var keys = new 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 = getMatching(settings.core.key);
+        var keys = new KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
+        var splits = new SplitsCacheInLocal(log, keys, expirationTimestamp, __splitFiltersValidation);
+        var segments = new MySegmentsCacheInLocal(log, keys);
         return {
-            splits: new SplitsCacheInLocal(log, keys, expirationTimestamp, params.splitFiltersValidation),
-            segments: new MySegmentsCacheInLocal(log, keys),
-            impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-            impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
-            events: new EventsCacheInMemory(params.eventsQueueSize),
-            telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
-            uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
+            splits: splits,
+            segments: segments,
+            impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+            impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+            events: new EventsCacheInMemory(eventsQueueSize),
+            telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+            uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
             destroy: function () {
                 var _a;
                 this.splits = new SplitsCacheInMemory();

package/esm/storages/inMemory/InMemoryStorage.js

@@ -3,23 +3,26 @@ import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
-import { TelemetryCacheInMemory } from './TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemory } from './uniqueKeysCacheInMemory';
+import { DEBUG, NONE, STORAGE_MEMORY } from '../../utils/constants';
+import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageFactory(params) {
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
+    var splits = new SplitsCacheInMemory();
+    var segments = new SegmentsCacheInMemory();
     return {
-        splits: new SplitsCacheInMemory(),
-        segments: new SegmentsCacheInMemory(),
-        impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
-        events: new EventsCacheInMemory(params.eventsQueueSize),
-        telemetry: params.mode !== LOCALHOST_MODE ? new TelemetryCacheInMemory() : undefined,
-        uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemory(params.uniqueKeysCacheSize) : undefined,
+        splits: splits,
+        segments: segments,
+        impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+        impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+        events: new EventsCacheInMemory(eventsQueueSize),
+        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+        uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemory() : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
             var _a;

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -3,23 +3,26 @@ import { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from './uniqueKeysCacheInMemoryCS';
+import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params) {
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
+    var splits = new SplitsCacheInMemory();
+    var segments = new MySegmentsCacheInMemory();
     return {
-        splits: new SplitsCacheInMemory(),
-        segments: new MySegmentsCacheInMemory(),
-        impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
-        events: new EventsCacheInMemory(params.eventsQueueSize),
-        telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
-        uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS(params.uniqueKeysCacheSize) : undefined,
+        splits: splits,
+        segments: segments,
+        impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
+        impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+        events: new EventsCacheInMemory(eventsQueueSize),
+        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+        uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
             var _a;