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

package/cjs/storages/pluggable/ImpressionsCachePluggable.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImpressionsCachePluggable = void 0;
+var utils_1 = require("../utils");
 var ImpressionsCachePluggable = /** @class */ (function () {
     function ImpressionsCachePluggable(log, key, wrapper, metadata) {
         this.log = log;
@@ -15,25 +16,7 @@ var ImpressionsCachePluggable = /** @class */ (function () {
      * or rejected if the wrapper operation fails.
      */
     ImpressionsCachePluggable.prototype.track = function (impressions) {
-        return this.wrapper.pushItems(this.key, this._toJSON(impressions));
-    };
-    ImpressionsCachePluggable.prototype._toJSON = function (impressions) {
-        var _this = this;
-        return impressions.map(function (impression) {
-            var keyName = impression.keyName, bucketingKey = impression.bucketingKey, feature = impression.feature, treatment = impression.treatment, label = impression.label, time = impression.time, changeNumber = impression.changeNumber;
-            return JSON.stringify({
-                m: _this.metadata,
-                i: {
-                    k: keyName,
-                    b: bucketingKey,
-                    f: feature,
-                    t: treatment,
-                    r: label,
-                    c: changeNumber,
-                    m: time
-                }
-            });
-        });
+        return this.wrapper.pushItems(this.key, (0, utils_1.impressionsToJSON)(impressions, this.metadata));
     };
     /**
      * Returns a promise that resolves with the count of stored impressions, or 0 if there was some error.

package/cjs/storages/pluggable/TelemetryCachePluggable.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelemetryCachePluggable = void 0;
-var KeyBuilderSS_1 = require("../KeyBuilderSS");
 var findLatencyIndex_1 = require("../findLatencyIndex");
 var telemetrySubmitter_1 = require("../../sync/submitters/telemetrySubmitter");
 var constants_1 = require("../../utils/constants");
 var lang_1 = require("../../utils/lang");
 var maps_1 = require("../../utils/lang/maps");
 var TelemetryCacheInMemory_1 = require("../inMemory/TelemetryCacheInMemory");
+var utils_1 = require("../utils");
 var TelemetryCachePluggable = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses a storage wrapper.
@@ -44,7 +44,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                     var result = new maps_1._Map();
                     for (var i = 0; i < latencyKeys.length; i++) {
                         var field = latencyKeys[i].split('::')[1];
-                        var parsedField = (0, KeyBuilderSS_1.parseLatencyField)(field);
+                        var parsedField = (0, utils_1.parseLatencyField)(field);
                         if ((0, lang_1.isString)(parsedField)) {
                             _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
                             continue;
@@ -88,7 +88,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                     var result = new maps_1._Map();
                     for (var i = 0; i < exceptionKeys.length; i++) {
                         var field = exceptionKeys[i].split('::')[1];
-                        var parsedField = (0, KeyBuilderSS_1.parseExceptionField)(field);
+                        var parsedField = (0, utils_1.parseExceptionField)(field);
                         if ((0, lang_1.isString)(parsedField)) {
                             _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
                             continue;
@@ -128,7 +128,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                     var result = new maps_1._Map();
                     for (var i = 0; i < configKeys.length; i++) {
                         var field = configKeys[i].split('::')[1];
-                        var parsedField = (0, KeyBuilderSS_1.parseMetadata)(field);
+                        var parsedField = (0, utils_1.parseMetadata)(field);
                         if ((0, lang_1.isString)(parsedField)) {
                             _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
                             continue;

package/cjs/storages/pluggable/inMemoryWrapper.js

@@ -37,29 +37,31 @@ function inMemoryWrapperFactory(connDelay) {
         getKeysByPrefix: function (prefix) {
             return Promise.resolve(Object.keys(_cache).filter(function (key) { return (0, lang_1.startsWith)(key, prefix); }));
         },
-        incr: function (key) {
+        incr: function (key, increment) {
+            if (increment === void 0) { increment = 1; }
             if (key in _cache) {
-                var count = (0, lang_1.toNumber)(_cache[key]) + 1;
+                var count = (0, lang_1.toNumber)(_cache[key]) + increment;
                 if (isNaN(count))
                     return Promise.reject('Given key is not a number');
                 _cache[key] = count + '';
                 return Promise.resolve(count);
             }
             else {
-                _cache[key] = '1';
+                _cache[key] = '' + increment;
                 return Promise.resolve(1);
             }
         },
-        decr: function (key) {
+        decr: function (key, decrement) {
+            if (decrement === void 0) { decrement = 1; }
             if (key in _cache) {
-                var count = (0, lang_1.toNumber)(_cache[key]) - 1;
+                var count = (0, lang_1.toNumber)(_cache[key]) - decrement;
                 if (isNaN(count))
                     return Promise.reject('Given key is not a number');
                 _cache[key] = count + '';
                 return Promise.resolve(count);
             }
             else {
-                _cache[key] = '-1';
+                _cache[key] = '-' + decrement;
                 return Promise.resolve(-1);
             }
         },

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 utils_1 = require("../utils");
 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, utils_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,7 +71,7 @@ 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

package/cjs/storages/utils.js

@@ -0,0 +1,73 @@
+"use strict";
+// Shared utils for Redis and Pluggable storage
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLatencyField = exports.parseExceptionField = exports.parseMetadata = exports.impressionsToJSON = exports.metadataBuilder = void 0;
+var constants_1 = require("../utils/constants");
+var TelemetryCacheInMemory_1 = require("./inMemory/TelemetryCacheInMemory");
+var KeyBuilderSS_1 = require("./KeyBuilderSS");
+function metadataBuilder(settings) {
+    return {
+        s: settings.version,
+        i: settings.runtime.ip || constants_1.UNKNOWN,
+        n: settings.runtime.hostname || constants_1.UNKNOWN,
+    };
+}
+exports.metadataBuilder = metadataBuilder;
+// Converts impressions to be stored in Redis or pluggable storage.
+function impressionsToJSON(impressions, metadata) {
+    return impressions.map(function (impression) {
+        var impressionWithMetadata = {
+            m: metadata,
+            i: {
+                k: impression.keyName,
+                b: impression.bucketingKey,
+                f: impression.feature,
+                t: impression.treatment,
+                r: impression.label,
+                c: impression.changeNumber,
+                m: impression.time,
+                pt: impression.pt,
+            }
+        };
+        return JSON.stringify(impressionWithMetadata);
+    });
+}
+exports.impressionsToJSON = impressionsToJSON;
+// Utilities used by TelemetryCacheInRedis and TelemetryCachePluggable
+var REVERSE_METHOD_NAMES = Object.keys(KeyBuilderSS_1.METHOD_NAMES).reduce(function (acc, key) {
+    acc[KeyBuilderSS_1.METHOD_NAMES[key]] = key;
+    return acc;
+}, {});
+function parseMetadata(field) {
+    var parts = field.split('/');
+    if (parts.length !== 3)
+        return "invalid subsection count. Expected 3, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */;
+    return [JSON.stringify({ s: s, n: n, i: i })];
+}
+exports.parseMetadata = parseMetadata;
+function parseExceptionField(field) {
+    var parts = field.split('/');
+    if (parts.length !== 4)
+        return "invalid subsection count. Expected 4, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3];
+    var method = REVERSE_METHOD_NAMES[m];
+    if (!method)
+        return "unknown method '" + m + "'";
+    return [JSON.stringify({ s: s, n: n, i: i }), method];
+}
+exports.parseExceptionField = parseExceptionField;
+function parseLatencyField(field) {
+    var parts = field.split('/');
+    if (parts.length !== 5)
+        return "invalid subsection count. Expected 5, got: " + parts.length;
+    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3], b = parts[4];
+    var method = REVERSE_METHOD_NAMES[m];
+    if (!method)
+        return "unknown method '" + m + "'";
+    var bucket = parseInt(b);
+    if (isNaN(bucket) || bucket >= TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT)
+        return "invalid bucket. Expected a number between 0 and " + (TelemetryCacheInMemory_1.MAX_LATENCY_BUCKET_COUNT - 1) + ", got: " + b;
+    return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
+}
+exports.parseLatencyField = parseLatencyField;

package/cjs/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);

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/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,43 +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,
-        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;
@@ -91,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/storages/KeyBuilderSS.js

@@ -1,7 +1,6 @@
 import { __extends } from "tslib";
 import { KeyBuilder } from './KeyBuilder';
-import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
-var METHOD_NAMES = {
+export var METHOD_NAMES = {
     t: 'treatment',
     ts: 'treatments',
     tc: 'treatmentWithConfig',
@@ -49,38 +48,3 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     return KeyBuilderSS;
 }(KeyBuilder));
 export { KeyBuilderSS };
-// Used by consumer methods of TelemetryCacheInRedis and TelemetryCachePluggable
-var REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce(function (acc, key) {
-    acc[METHOD_NAMES[key]] = key;
-    return acc;
-}, {});
-export function parseMetadata(field) {
-    var parts = field.split('/');
-    if (parts.length !== 3)
-        return "invalid subsection count. Expected 3, got: " + parts.length;
-    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */;
-    return [JSON.stringify({ s: s, n: n, i: i })];
-}
-export function parseExceptionField(field) {
-    var parts = field.split('/');
-    if (parts.length !== 4)
-        return "invalid subsection count. Expected 4, got: " + parts.length;
-    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3];
-    var method = REVERSE_METHOD_NAMES[m];
-    if (!method)
-        return "unknown method '" + m + "'";
-    return [JSON.stringify({ s: s, n: n, i: i }), method];
-}
-export function parseLatencyField(field) {
-    var parts = field.split('/');
-    if (parts.length !== 5)
-        return "invalid subsection count. Expected 5, got: " + parts.length;
-    var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3], b = parts[4];
-    var method = REVERSE_METHOD_NAMES[m];
-    if (!method)
-        return "unknown method '" + m + "'";
-    var bucket = parseInt(b);
-    if (isNaN(bucket) || bucket >= MAX_LATENCY_BUCKET_COUNT)
-        return "invalid bucket. Expected a number between 0 and " + (MAX_LATENCY_BUCKET_COUNT - 1) + ", got: " + b;
-    return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
-}

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 { 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 { 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: shouldRecordTelemetry(params) ? 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

@@ -12,14 +12,17 @@ import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
  * @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: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
-        uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemory() : 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

@@ -12,14 +12,17 @@ import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
  * @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: shouldRecordTelemetry(params) ? 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,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
             var _a;