@splitsoftware/splitio-commons 1.3.1 → 1.3.2-rc.2

package/esm/logger/messages/error.js

@@ -31,5 +31,6 @@ export var codesError = [
     // initialization / settings validation
     [c.ERROR_INVALID_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "%s" config param. It should be one of the following values: %s. Defaulting to "%s".'],
     [c.ERROR_LOCALHOST_MODULE_REQUIRED, c.LOG_PREFIX_SETTINGS + ': an invalid value was received for "sync.localhostMode" config. A valid entity should be provided for localhost mode.'],
-    [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS + ': The provided storage is invalid.%s Fallbacking into default MEMORY storage'],
+    [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS + ': the provided storage is invalid.%s Falling back into default MEMORY storage'],
+    [c.ERROR_MIN_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': the provided "%s" config param is lower than allowed. Setting to the minimum value %s seconds'],
 ];

package/esm/logger/messages/info.js

@@ -12,8 +12,8 @@ export var codesInfo = codesWarn.concat([
     [c.NEW_FACTORY, 'New Split SDK instance created.'],
     [c.EVENTS_TRACKER_SUCCESS, c.LOG_PREFIX_EVENTS_TRACKER + 'Successfully queued %s'],
     [c.IMPRESSIONS_TRACKER_SUCCESS, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Successfully stored %s impression(s).'],
-    [c.USER_CONSENT_UPDATED, 'setUserConsent: consent status changed from %s to %s.'],
-    [c.USER_CONSENT_NOT_UPDATED, 'setUserConsent: call had no effect because it was the current consent status (%s).'],
+    [c.USER_CONSENT_UPDATED, 'UserConsent: consent status changed from %s to %s.'],
+    [c.USER_CONSENT_NOT_UPDATED, 'UserConsent: call had no effect because it was the current consent status (%s).'],
     [c.USER_CONSENT_INITIAL, 'Starting the SDK with %s user consent. No data will be sent.'],
     // synchronizer
     [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],
@@ -21,7 +21,7 @@ export var codesInfo = codesWarn.concat([
     [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
     [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of splits #%s. Reason: %s'],
     [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
-    [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s %s.'],
+    [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
     [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
     [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],
     [c.STREAMING_CONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Connecting streaming.'],

package/esm/logger/messages/warn.js

@@ -10,8 +10,8 @@ export var codesWarn = codesError.concat([
     [c.STREAMING_PARSING_ERROR_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE error notification: %s'],
     [c.STREAMING_PARSING_MESSAGE_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE message notification: %s'],
     [c.STREAMING_FALLBACK, c.LOG_PREFIX_SYNC_STREAMING + 'Falling back to polling mode. Reason: %s'],
-    [c.SUBMITTERS_PUSH_FAILS, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Droping %s %s after retry. Reason: %s.'],
-    [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s %s, keeping data to retry on next iteration. Reason: %s.'],
+    [c.SUBMITTERS_PUSH_FAILS, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Droping %s after retry. Reason: %s.'],
+    [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s, keeping data to retry on next iteration. Reason: %s.'],
     // client status
     [c.CLIENT_NOT_READY, '%s: the SDK is not ready, results may be incorrect. Make sure to wait for SDK readiness before using this method.'],
     [c.CLIENT_NO_LISTENER, 'No listeners for SDK Readiness detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet ready.'],

package/esm/sdkClient/client.js

@@ -4,21 +4,22 @@ import { getMatching, getBucketing } from '../utils/key';
 import { validateSplitExistance } from '../utils/inputValidation/splitExistance';
 import { validateTrafficTypeExistance } from '../utils/inputValidation/trafficTypeExistance';
 import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL } from '../utils/constants';
+import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK } from '../utils/constants';
 import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
 /**
  * Creator of base client with getTreatments and track methods.
  */
-// @TODO missing time tracking to collect telemetry
 export function clientFactory(params) {
-    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker;
+    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker, telemetryTracker = params.telemetryTracker;
     var log = settings.log, mode = settings.mode;
     function getTreatment(key, splitName, attributes, withConfig) {
         if (withConfig === void 0) { withConfig = false; }
+        var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
         var wrapUp = function (evaluationResult) {
             var queue = [];
             var treatment = processEvaluation(evaluationResult, splitName, key, attributes, withConfig, "getTreatment" + (withConfig ? 'withConfig' : ''), queue);
             impressionsTracker.track(queue, attributes);
+            stopTelemetryTracker(queue[0] && queue[0].label);
             return treatment;
         };
         var evaluation = evaluateFeature(log, key, splitName, attributes, storage);
@@ -29,6 +30,7 @@ export function clientFactory(params) {
     }
     function getTreatments(key, splitNames, attributes, withConfig) {
         if (withConfig === void 0) { withConfig = false; }
+        var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
@@ -36,6 +38,7 @@ export function clientFactory(params) {
                 treatments[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, "getTreatments" + (withConfig ? 'withConfig' : ''), queue);
             });
             impressionsTracker.track(queue, attributes);
+            stopTelemetryTracker(queue[0] && queue[0].label);
             return treatments;
         };
         var evaluations = evaluateFeatures(log, key, splitNames, attributes, storage);
@@ -77,6 +80,7 @@ export function clientFactory(params) {
     }
     function track(key, trafficTypeName, eventTypeId, value, properties, size) {
         if (size === void 0) { size = 1024; }
+        var stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
         var matchingKey = getMatching(key);
         var timestamp = Date.now();
         var eventData = {
@@ -89,7 +93,17 @@ export function clientFactory(params) {
         };
         // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
         validateTrafficTypeExistance(log, readinessManager, storage.splits, mode, trafficTypeName, 'track');
-        return eventTracker.track(eventData, size);
+        var result = eventTracker.track(eventData, size);
+        if (thenable(result)) {
+            return result.then(function (result) {
+                stopTelemetryTracker();
+                return result;
+            });
+        }
+        else {
+            stopTelemetryTracker();
+            return result;
+        }
     }
     return {
         getTreatment: getTreatment,

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;
+    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), 
@@ -15,6 +15,9 @@ export function sdkClientFactory(params, isSharedClient) {
     // Sdk destroy
     {
         destroy: function () {
+            // record stat before flushing data
+            if (!isSharedClient)
+                telemetryTracker.sessionLength();
             // Stop background jobs
             syncManager && syncManager.stop();
             var flush = syncManager ? syncManager.flush() : Promise.resolve();

package/esm/sdkFactory/index.js

@@ -1,6 +1,7 @@
 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';
@@ -15,12 +16,12 @@ import { objectAssign } from '../utils/lang/objectAssign';
 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;
     var log = settings.log;
-    // @TODO handle non-recoverable errors: not start sync, mark the SDK as destroyed, etc.
+    // @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);
-    // @TODO handle non-recoverable error, such as, `fetch` api not available, invalid API Key, etc.
     var sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
-    var readinessManager = sdkReadinessManager.readinessManager;
+    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,
@@ -36,32 +37,28 @@ export function sdkFactory(params) {
         onReadyCb: function (error) {
             if (error)
                 return; // Don't emit SDK_READY if storage failed to connect. Error message is logged by wrapperAdapter
-            readinessManager.splits.emit(SDK_SPLITS_ARRIVED);
-            readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
+            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);`
-    // splitApi is used by SyncManager and Browser signal listener
-    var splitApi = splitApiFactory && splitApiFactory(settings, platform);
-    var syncManager = syncManagerFactory && syncManagerFactory({
-        settings: settings,
-        splitApi: splitApi,
-        storage: storage,
-        readiness: sdkReadinessManager.readinessManager,
-        platform: platform
-    });
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage });
     // trackers
     var observer = impressionsObserverFactory && impressionsObserverFactory();
-    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts);
-    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager);
-    // signal listener
+    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts, storage.telemetry);
+    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
+    var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
+    // 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, 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);
-    // Sdk client and manager
-    var ctx = { eventTracker: eventTracker, impressionsTracker: impressionsTracker, sdkReadinessManager: sdkReadinessManager, settings: settings, storage: storage, syncManager: syncManager, signalListener: signalListener };
+    ctx.signalListener = signalListener;
+    // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
     var managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);
     syncManager && syncManager.start();

package/esm/services/splitApi.js

@@ -1,5 +1,6 @@
 import { splitHttpClientFactory } from './splitHttpClient';
 import { objectAssign } from '../utils/lang/objectAssign';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
     return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
@@ -10,7 +11,7 @@ function userKeyToQueryParam(userKey) {
  * @param settings validated settings object
  * @param platform object containing environment-specific `getFetch` and `getOptions` dependencies
  */
-export function splitApiFactory(settings, platform) {
+export function splitApiFactory(settings, platform, telemetryTracker) {
     var urls = settings.urls;
     var filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
@@ -31,15 +32,15 @@ export function splitApiFactory(settings, platform) {
                 if (queryParams) // accounting the possibility that `userKeys` and thus `queryParams` are empty
                     url += '?' + queryParams;
             }
-            return splitHttpClient(url);
+            return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
         },
         fetchSplitChanges: function (since, noCache) {
             var url = urls.sdk + "/splitChanges?since=" + since + (filterQueryString || '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS));
         },
         fetchSegmentChanges: function (since, segmentName, noCache) {
             var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since;
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
         },
         fetchMySegments: function (userMatchingKey, noCache) {
             /**
@@ -49,7 +50,7 @@ export function splitApiFactory(settings, platform) {
              *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
              */
             var url = urls.sdk + "/mySegments/" + encodeURIComponent(userMatchingKey);
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
         },
         /**
          * Post events.
@@ -59,7 +60,7 @@ export function splitApiFactory(settings, platform) {
          */
         postEventsBulk: function (body, headers) {
             var url = urls.events + "/events/bulk";
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers });
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(EVENTS));
         },
         /**
          * Post impressions.
@@ -74,7 +75,7 @@ export function splitApiFactory(settings, platform) {
                 method: 'POST',
                 body: body,
                 headers: objectAssign({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
-            });
+            }, telemetryTracker.trackHttp(IMPRESSIONS));
         },
         /**
          * Post impressions counts.
@@ -84,15 +85,15 @@ export function splitApiFactory(settings, platform) {
          */
         postTestImpressionsCount: function (body, headers) {
             var url = urls.events + "/testImpressions/count";
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers });
+            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
         },
-        postMetricsCounters: function (body) {
-            var url = urls.events + "/metrics/counters";
-            return splitHttpClient(url, { method: 'POST', body: body }, true);
+        postMetricsConfig: function (body) {
+            var url = urls.telemetry + "/v1/metrics/config";
+            return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(TELEMETRY), true);
         },
-        postMetricsTimes: function (body) {
-            var url = urls.events + "/metrics/times";
-            return splitHttpClient(url, { method: 'POST', body: body }, true);
+        postMetricsUsage: function (body) {
+            var url = urls.telemetry + "/v1/metrics/usage";
+            return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(TELEMETRY), true);
         }
     };
 }

package/esm/services/splitHttpClient.js

@@ -25,8 +25,9 @@ export function splitHttpClientFactory(settings, getFetch, getOptions) {
         headers['SplitSDKMachineIP'] = ip;
     if (hostname)
         headers['SplitSDKMachineName'] = hostname;
-    return function httpClient(url, reqOpts, logErrorsAsInfo) {
+    return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo) {
         if (reqOpts === void 0) { reqOpts = {}; }
+        if (latencyTracker === void 0) { latencyTracker = function () { }; }
         if (logErrorsAsInfo === void 0) { logErrorsAsInfo = false; }
         var request = objectAssign({
             headers: reqOpts.headers ? objectAssign({}, headers, reqOpts.headers) : headers,
@@ -40,6 +41,7 @@ export function splitHttpClientFactory(settings, getFetch, getOptions) {
             if (!response.ok) {
                 return response.text().then(function (message) { return Promise.reject({ response: response, message: message }); });
             }
+            latencyTracker();
             return response;
         })
             .catch(function (error) {
@@ -65,6 +67,7 @@ export function splitHttpClientFactory(settings, getFetch, getOptions) {
             var networkError = new Error(msg);
             // passes `undefined` as statusCode if not an HTTP error (resp === undefined)
             networkError.statusCode = resp && resp.status;
+            latencyTracker(networkError);
             throw networkError;
         }) : Promise.reject(new Error(messageNoFetch));
     };

package/esm/storages/AbstractSegmentsCacheSync.js

@@ -10,11 +10,6 @@ var AbstractSegmentsCacheSync = /** @class */ (function () {
      * For client-side synchronizer: the method is not used.
      */
     AbstractSegmentsCacheSync.prototype.registerSegments = function (names) { return false; };
-    /**
-     * For server-side synchronizer: get the list of segments in the cache.
-     * For client-side synchronizer: the method is not used.
-     */
-    AbstractSegmentsCacheSync.prototype.getRegisteredSegments = function () { return []; };
     /**
      * For server-side synchronizer: set the change number of `name` segment.
      * For client-side synchronizer: the method is not used.

package/esm/storages/KeyBuilderSS.js

@@ -1,8 +1,12 @@
 import { __extends } from "tslib";
 import { KeyBuilder } from './KeyBuilder';
-// NOT USED
-// const everythingAfterCount = /count\.([^/]+)$/;
-// const latencyMetricNameAndBucket = /latency\.([^/]+)\.bucket\.([0-9]+)$/;
+var methodNames = {
+    t: 'treatment',
+    ts: 'treatments',
+    tc: 'treatmentWithConfig',
+    tcs: 'treatmentsWithConfig',
+    tr: 'track'
+};
 var KeyBuilderSS = /** @class */ (function (_super) {
     __extends(KeyBuilderSS, _super);
     function KeyBuilderSS(prefix, metadata) {
@@ -14,7 +18,7 @@ var KeyBuilderSS = /** @class */ (function (_super) {
         return this.prefix + ".segments.registered";
     };
     KeyBuilderSS.prototype.buildVersionablePrefix = function () {
-        return this.prefix + "/" + this.metadata.s + "/" + this.metadata.i;
+        return this.metadata.s + "/" + this.metadata.n + "/" + this.metadata.i;
     };
     KeyBuilderSS.prototype.buildImpressionsKey = function () {
         return this.prefix + ".impressions";
@@ -22,23 +26,12 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.buildEventsKey = function () {
         return this.prefix + ".events";
     };
-    KeyBuilderSS.prototype.buildLatencyKeyPrefix = function () {
-        return this.buildVersionablePrefix() + "/latency";
+    KeyBuilderSS.prototype.buildLatencyKey = function (method, bucket) {
+        return this.prefix + ".telemetry.latencies::" + this.buildVersionablePrefix() + "/" + methodNames[method] + "/" + bucket;
     };
-    KeyBuilderSS.prototype.buildLatencyKey = function (metricName, bucketNumber) {
-        return this.buildLatencyKeyPrefix() + "." + metricName + ".bucket." + bucketNumber;
+    KeyBuilderSS.prototype.buildExceptionKey = function (method) {
+        return this.prefix + ".telemetry.exceptions::" + this.buildVersionablePrefix() + "/" + methodNames[method];
     };
-    KeyBuilderSS.prototype.buildCountKey = function (metricName) {
-        return this.buildVersionablePrefix() + "/count." + metricName;
-    };
-    // NOT USED
-    // buildGaugeKey(metricName: string) {
-    //   return `${this.buildVersionablePrefix()}/gauge.${metricName}`;
-    // }
-    // NOT USED
-    // searchPatternForCountKeys() {
-    //   return `${this.buildVersionablePrefix()}/count.*`;
-    // }
     KeyBuilderSS.prototype.searchPatternForSplitKeys = function () {
         return this.buildSplitKeyPrefix() + "*";
     };

package/esm/storages/findLatencyIndex.js

@@ -1,9 +1,14 @@
 import { isNaNNumber } from '../utils/lang';
-// @TODO add unit tests
-export function findLatencyIndex(latency, min, max, base) {
-    if (min === void 0) { min = 0; }
-    if (max === void 0) { max = 23; }
-    if (base === void 0) { base = 1.5; }
-    var index = Math.min(max, Math.max(min, Math.floor(Math.log(latency) / Math.log(base))));
+var MIN = 0;
+var MAX = 22;
+var BASE = 1.5;
+/**
+ * Calculates buckets from latency in milliseconds
+ *
+ * @param latencyInMs
+ * @returns a bucket index from 0 to 22 inclusive
+ */
+export function findLatencyIndex(latencyInMs) {
+    var index = Math.min(MAX, Math.max(MIN, Math.ceil(Math.log(latencyInMs) / Math.log(BASE))));
     return isNaNNumber(index) ? 0 : index; // index is NaN if latency is not a positive number
 }

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -62,7 +62,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
                 accum.push(segmentName);
             }
             else {
-                // @BREAKING: This is only to clean up "old" keys. Remove this whole else code block.
+                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
                 segmentName = _this.keys.extractOldSegmentKey(key);
                 if (segmentName) { // this was an old segment key, let's clean up.
                     var newSegmentKey = _this.keys.buildSegmentNameKey(segmentName);
@@ -104,6 +104,18 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         }
         return isDiff;
     };
+    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
+        var _this = this;
+        return Object.keys(localStorage).reduce(function (accum, key) {
+            var segmentName = _this.keys.extractSegmentName(key);
+            if (segmentName)
+                accum.push(segmentName);
+            return accum;
+        }, []);
+    };
+    MySegmentsCacheInLocal.prototype.getKeysCount = function () {
+        return 1;
+    };
     return MySegmentsCacheInLocal;
 }(AbstractSegmentsCacheSync));
 export { MySegmentsCacheInLocal };

package/esm/storages/inLocalStorage/index.js

@@ -11,7 +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 { STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -21,7 +22,7 @@ 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. Fallbacking into default MEMORY storage');
+            params.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return InMemoryStorageCSFactory(params);
         }
         var log = params.log;
@@ -33,6 +34,7 @@ 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,
             destroy: function () {
                 this.splits = new SplitsCacheInMemory();
                 this.segments = new MySegmentsCacheInMemory();
@@ -49,6 +51,7 @@ export function InLocalStorage(options) {
                     impressions: this.impressions,
                     impressionCounts: this.impressionCounts,
                     events: this.events,
+                    telemetry: this.telemetry,
                     destroy: function () {
                         this.splits = new SplitsCacheInMemory();
                         this.segments = new MySegmentsCacheInMemory();

package/esm/storages/inMemory/InMemoryStorage.js

@@ -3,7 +3,8 @@ import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { STORAGE_MEMORY } from '../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
+import { TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
@@ -16,6 +17,7 @@ export function InMemoryStorageFactory(params) {
         impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
         impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory(params.eventsQueueSize),
+        telemetry: params.mode !== LOCALHOST_MODE ? new TelemetryCacheInMemory() : undefined,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
             this.splits.clear();

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -3,7 +3,8 @@ import { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { STORAGE_MEMORY } from '../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
+import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
@@ -16,6 +17,7 @@ export function InMemoryStorageCSFactory(params) {
         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,
         // When using MEMORY we should clean all the caches to leave them empty
         destroy: function () {
             this.splits.clear();
@@ -32,6 +34,7 @@ export function InMemoryStorageCSFactory(params) {
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
+                telemetry: this.telemetry,
                 // Set a new splits cache to clean it for the client without affecting other clients
                 destroy: function () {
                     this.splits = new SplitsCacheInMemory();

package/esm/storages/inMemory/MySegmentsCacheInMemory.js

@@ -63,6 +63,12 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         }
         return isDiff;
     };
+    MySegmentsCacheInMemory.prototype.getRegisteredSegments = function () {
+        return Object.keys(this.segmentCache);
+    };
+    MySegmentsCacheInMemory.prototype.getKeysCount = function () {
+        return 1;
+    };
     return MySegmentsCacheInMemory;
 }(AbstractSegmentsCacheSync));
 export { MySegmentsCacheInMemory };

package/esm/storages/inMemory/SegmentsCacheInMemory.js

@@ -54,6 +54,12 @@ var SegmentsCacheInMemory = /** @class */ (function (_super) {
     SegmentsCacheInMemory.prototype.getRegisteredSegments = function () {
         return Object.keys(this.segmentCache);
     };
+    SegmentsCacheInMemory.prototype.getKeysCount = function () {
+        var _this = this;
+        return Object.keys(this.segmentCache).reduce(function (acum, segmentName) {
+            return acum + _this.segmentCache[segmentName].size;
+        }, 0);
+    };
     SegmentsCacheInMemory.prototype.setChangeNumber = function (name, changeNumber) {
         this.segmentChangeNumber[name] = changeNumber;
         return true;