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

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

@@ -6,7 +6,7 @@ import { clientInputValidationDecorator } from './clientInputValidation';
  * Creates an Sdk client, i.e., a base client with status and destroy interface
  */
 export function sdkClientFactory(params, isSharedClient) {
-    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker, uniqueKeysTracker = params.uniqueKeysTracker;
+    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker;
     return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
@@ -28,8 +28,6 @@ export function sdkClientFactory(params, isSharedClient) {
                 // Release the API Key if it is the main client
                 if (!isSharedClient)
                     releaseApiKey(settings.core.authorizationKey);
-                if (uniqueKeysTracker)
-                    uniqueKeysTracker.stop();
                 // Cleanup storage
                 return storage.destroy();
             });

package/esm/sdkFactory/index.js

@@ -10,16 +10,11 @@ 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';
-import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
-import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
-import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { NONE, OPTIMIZED } from '../utils/constants';
 /**
  * Modular SDK factory
  */
 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 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;
     var log = settings.log;
     // @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.
@@ -31,14 +26,12 @@ export function sdkFactory(params) {
     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.
         onReadyCb: function (error) {
@@ -54,24 +47,13 @@ export function sdkFactory(params) {
     // @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 strategy;
-    switch (storageFactoryParams.impressionsMode) {
-        case OPTIMIZED:
-            strategy = strategyOptimizedFactory(observer, storage.impressionCounts);
-            break;
-        case NONE:
-            strategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
-            break;
-        default:
-            strategy = strategyDebugFactory(observer);
-    }
-    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
+    // trackers
+    var observer = impressionsObserverFactory && impressionsObserverFactory();
+    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts, storage.telemetry);
     var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
+    var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);

package/esm/services/splitApi.js

@@ -87,33 +87,13 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             var url = urls.events + "/testImpressions/count";
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
         },
-        /**
-         * Post unique keys for client side.
-         *
-         * @param body  unique keys payload
-         * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postUniqueKeysBulkCs: function (body, headers) {
-            var url = urls.telemetry + "/v1/keys/cs";
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
-        },
-        /**
-         * Post unique keys for server side.
-         *
-         * @param body  unique keys payload
-         * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-         */
-        postUniqueKeysBulkSs: function (body, headers) {
-            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/KeyBuilderSS.js

@@ -1,6 +1,7 @@
 import { __extends } from "tslib";
 import { KeyBuilder } from './KeyBuilder';
-var methodNames = {
+import { MAX_LATENCY_BUCKET_COUNT } from './inMemory/TelemetryCacheInMemory';
+var METHOD_NAMES = {
     t: 'treatment',
     ts: 'treatments',
     tc: 'treatmentWithConfig',
@@ -11,7 +12,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 () {
@@ -20,12 +24,6 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.buildImpressionsKey = function () {
         return this.prefix + ".impressions";
     };
-    KeyBuilderSS.prototype.buildImpressionsCountKey = function () {
-        return this.prefix + ".impressions.count";
-    };
-    KeyBuilderSS.prototype.buildUniqueKeysKey = function () {
-        return this.prefix + ".uniquekeys";
-    };
     KeyBuilderSS.prototype.buildEventsKey = function () {
         return this.prefix + ".events";
     };
@@ -34,17 +32,49 @@ 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));
 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 4, 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 22, got: " + b;
+    return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
+}

package/esm/storages/inLocalStorage/index.js

@@ -11,9 +11,8 @@ 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 { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from '../inMemory/uniqueKeysCacheInMemoryCS';
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -35,16 +34,13 @@ export function InLocalStorage(options) {
             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,
+            telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
             destroy: function () {
-                var _a;
                 this.splits = new SplitsCacheInMemory();
                 this.segments = new MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
                 this.events.clear();
-                (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
             },
             // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {

package/esm/storages/inMemory/ImpressionCountsCacheInMemory.js

@@ -1,11 +1,7 @@
 import { truncateTimeFrame } from '../../utils/time';
-import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 var ImpressionCountsCacheInMemory = /** @class */ (function () {
-    function ImpressionCountsCacheInMemory(impressionCountsCacheSize) {
-        if (impressionCountsCacheSize === void 0) { impressionCountsCacheSize = DEFAULT_CACHE_SIZE; }
+    function ImpressionCountsCacheInMemory() {
         this.cache = {};
-        this.cacheSize = 0;
-        this.maxStorage = impressionCountsCacheSize;
     }
     /**
     * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
@@ -20,13 +16,6 @@ var ImpressionCountsCacheInMemory = /** @class */ (function () {
         var key = this._makeKey(featureName, timeFrame);
         var currentAmount = this.cache[key];
         this.cache[key] = currentAmount ? currentAmount + amount : amount;
-        if (this.onFullQueue) {
-            this.cacheSize = this.cacheSize + amount;
-            if (this.cacheSize >= this.maxStorage) {
-                this.onFullQueue();
-                this.cacheSize = 0;
-            }
-        }
     };
     /**
      * Pop the collected data, used as payload for posting.

package/esm/storages/inMemory/InMemoryStorage.js

@@ -3,9 +3,8 @@ 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 { STORAGE_MEMORY } from '../../utils/constants';
+import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
@@ -16,19 +15,16 @@ export function InMemoryStorageFactory(params) {
         splits: new SplitsCacheInMemory(),
         segments: new SegmentsCacheInMemory(),
         impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+        impressionCounts: params.optimize ? 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,
+        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
-            var _a;
             this.splits.clear();
             this.segments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
-            (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
         }
     };
 }

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -3,9 +3,8 @@ 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 { STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from './uniqueKeysCacheInMemoryCS';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
@@ -16,19 +15,16 @@ export function InMemoryStorageCSFactory(params) {
         splits: new SplitsCacheInMemory(),
         segments: new MySegmentsCacheInMemory(),
         impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-        impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+        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(params.uniqueKeysCacheSize) : undefined,
+        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory() : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
-            var _a;
             this.splits.clear();
             this.segments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
-            (_a = this.uniqueKeys) === null || _a === void 0 ? void 0 : _a.clear();
         },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -1,16 +1,18 @@
+import { LOCALHOST_MODE } from '../../utils/constants';
 import { findLatencyIndex } from '../findLatencyIndex';
 var MAX_STREAMING_EVENTS = 20;
 var MAX_TAGS = 10;
-function newBuckets() {
-    // MAX_LATENCY_BUCKET_COUNT (length) is 23;
-    return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+export var MAX_LATENCY_BUCKET_COUNT = 23;
+export function newBuckets() {
+    return new Array(MAX_LATENCY_BUCKET_COUNT).fill(0);
 }
 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.
  */
-export function shouldRecordTelemetry() {
-    return Math.random() <= ACCEPTANCE_RANGE;
+export function shouldRecordTelemetry(params) {
+    return params.mode !== LOCALHOST_MODE && (params.matchingKey === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 var TelemetryCacheInMemory = /** @class */ (function () {
     function TelemetryCacheInMemory() {

package/esm/storages/inRedis/EventsCacheInRedis.js

@@ -39,7 +39,7 @@ var EventsCacheInRedis = /** @class */ (function () {
     };
     /**
      * Pop the given number of events from the storage.
-     * The returned promise rejects if the wrapper operation fails.
+     * The returned promise rejects if the redis operation fails.
      *
      * NOTE: this method doesn't take into account MAX_EVENT_SIZE or MAX_QUEUE_BYTE_SIZE limits.
      * It is the submitter responsability to handle that.

package/esm/storages/inRedis/TelemetryCacheInRedis.js

@@ -1,6 +1,10 @@
+import { parseExceptionField, parseLatencyField, parseMetadata } from '../KeyBuilderSS';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
+import { isNaNNumber, isString } from '../../utils/lang';
+import { _Map } from '../../utils/lang/maps';
+import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 var TelemetryCacheInRedis = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses Redis as storage.
@@ -28,6 +32,102 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         var value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, STORAGE_REDIS));
         return this.redis.hset(key, field, value).catch(function () { });
     };
+    /**
+     * Pop telemetry latencies.
+     * The returned promise rejects if redis operations fail.
+     */
+    TelemetryCacheInRedis.prototype.popLatencies = function () {
+        var _this = this;
+        return this.redis.hgetall(this.keys.latencyPrefix).then(function (latencies) {
+            var result = new _Map();
+            Object.keys(latencies).forEach(function (field) {
+                var parsedField = parseLatencyField(field);
+                if (isString(parsedField)) {
+                    _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                    return;
+                }
+                var count = parseInt(latencies[field]);
+                if (isNaNNumber(count)) {
+                    _this.log.error("Ignoring latency with invalid count: " + latencies[field]);
+                    return;
+                }
+                var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
+                if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
+                    _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                    return;
+                }
+                if (!result.has(metadata))
+                    result.set(metadata, {
+                        t: newBuckets(),
+                        ts: newBuckets(),
+                        tc: newBuckets(),
+                        tcs: newBuckets(),
+                        tr: newBuckets(),
+                    });
+                result.get(metadata)[method][bucket] = count;
+            });
+            return _this.redis.del(_this.keys.latencyPrefix).then(function () { return result; });
+        });
+    };
+    /**
+     * Pop telemetry exceptions.
+     * The returned promise rejects if redis operations fail.
+     */
+    TelemetryCacheInRedis.prototype.popExceptions = function () {
+        var _this = this;
+        return this.redis.hgetall(this.keys.exceptionPrefix).then(function (exceptions) {
+            var result = new _Map();
+            Object.keys(exceptions).forEach(function (field) {
+                var parsedField = parseExceptionField(field);
+                if (isString(parsedField)) {
+                    _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                    return;
+                }
+                var count = parseInt(exceptions[field]);
+                if (isNaNNumber(count)) {
+                    _this.log.error("Ignoring exception with invalid count: " + exceptions[field]);
+                    return;
+                }
+                var metadata = parsedField[0], method = parsedField[1];
+                if (!result.has(metadata))
+                    result.set(metadata, {
+                        t: 0,
+                        ts: 0,
+                        tc: 0,
+                        tcs: 0,
+                        tr: 0,
+                    });
+                result.get(metadata)[method] = count;
+            });
+            return _this.redis.del(_this.keys.exceptionPrefix).then(function () { return result; });
+        });
+    };
+    /**
+     * Pop telemetry configs.
+     * The returned promise rejects if redis operations fail.
+     */
+    TelemetryCacheInRedis.prototype.popConfigs = function () {
+        var _this = this;
+        return this.redis.hgetall(this.keys.initPrefix).then(function (configs) {
+            var result = new _Map();
+            Object.keys(configs).forEach(function (field) {
+                var parsedField = parseMetadata(field);
+                if (isString(parsedField)) {
+                    _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                    return;
+                }
+                var metadata = parsedField[0];
+                try {
+                    var config = JSON.parse(configs[field]);
+                    result.set(metadata, config);
+                }
+                catch (e) {
+                    _this.log.error("Ignoring invalid config: " + configs[field]);
+                }
+            });
+            return _this.redis.del(_this.keys.initPrefix).then(function () { return result; });
+        });
+    };
     return TelemetryCacheInRedis;
 }());
 export { TelemetryCacheInRedis };

package/esm/storages/inRedis/constants.js

@@ -1,4 +1 @@
 export var LOG_PREFIX = 'storage:redis: ';
-export var DEFAULT_CACHE_SIZE = 30000;
-export var REFRESH_RATE = 300000; // 300.000 ms = start after 5 mins
-export var TTL_REFRESH = 3600; // 1hr

package/esm/storages/inRedis/index.js

@@ -5,10 +5,8 @@ import { SplitsCacheInRedis } from './SplitsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
-import { DEBUG, NONE, STORAGE_REDIS } from '../../utils/constants';
+import { STORAGE_REDIS } from '../../utils/constants';
 import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
-import { UniqueKeysCacheInRedis } from './uniqueKeysCacheInRedis';
-import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
 /**
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
@@ -17,19 +15,13 @@ export function InRedisStorage(options) {
     if (options === void 0) { options = {}; }
     var prefix = validatePrefix(options.prefix);
     function InRedisStorageFactory(_a) {
-        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, impressionsMode = _a.impressionsMode;
+        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb;
         var keys = new KeyBuilderSS(prefix, metadata);
         var redisClient = new RedisAdapter(log, options.options || {});
         var telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
-        var impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
-        var uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
         // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
         redisClient.on('connect', function () {
             onReadyCb();
-            if (impressionCountsCache)
-                impressionCountsCache.start();
-            if (uniqueKeysCache)
-                uniqueKeysCache.start();
             // Synchronize config
             telemetry.recordConfig();
         });
@@ -37,19 +29,12 @@ export function InRedisStorage(options) {
             splits: new SplitsCacheInRedis(log, keys, redisClient),
             segments: new SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
-            impressionCounts: impressionCountsCache,
             events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
             telemetry: telemetry,
-            uniqueKeys: uniqueKeysCache,
             // When using REDIS we should:
             // 1- Disconnect from the storage
             destroy: function () {
-                var promises = [];
-                if (impressionCountsCache)
-                    promises.push(impressionCountsCache.stop());
-                if (uniqueKeysCache)
-                    promises.push(uniqueKeysCache.stop());
-                return Promise.all(promises).then(function () { redisClient.disconnect(); });
+                redisClient.disconnect();
                 // @TODO check that caches works as expected when redisClient is disconnected
             }
         };