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

package/CHANGES.txt

@@ -1,3 +1,8 @@
+1.4.0 (May XX, 2022)
+ - Added `scheduler.telemetryRefreshRate` property to SDK configuration, and deprecated `scheduler.metricsRefreshRate` property.
+ - Updated SDK telemetry storage, metrics and updater to be more effective and send less often.
+ - Bugfixing - Updated default values for `scheduler.impressionsRefreshRate` config parameter: 300s for OPTIMIZED impression mode and 60s for DEBUG impression mode.
+
 1.3.1 (April 19, 2022)
  - Bugfixing - Added peer dependencies to avoid issues when requiring some third-party dependencies used by modules of the package (Related to issue https://github.com/splitio/javascript-client/issues/662).
  - Bugfixing - Updated `ready` method to rejects the promise with an Error object instead of a string value (Related to issue https://github.com/splitio/javascript-client/issues/654).

package/cjs/listeners/browser.js

@@ -7,6 +7,7 @@ var constants_1 = require("../utils/constants");
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_2 = require("../logger/constants");
 var consent_1 = require("../consent");
+var telemetrySubmitter_1 = require("../sync/submitters/telemetrySubmitter");
 // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
 var UNLOAD_DOM_EVENT = 'unload';
 var EVENT_NAME = 'for unload page event.';
@@ -63,7 +64,11 @@ var BrowserSignalListener = /** @class */ (function () {
             this._flushData(eventsUrl + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
             if (this.storage.impressionCounts)
                 this._flushData(eventsUrl + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, impressionCountsSubmitter_1.fromImpressionCountsCollector);
-            // No beacon endpoint for `/metrics/usage`
+            if (this.storage.telemetry) {
+                var telemetryUrl = this.settings.urls.telemetry;
+                var telemetryCacheAdapter = (0, telemetrySubmitter_1.telemetryCacheStatsAdapter)(this.storage.telemetry, this.storage.splits, this.storage.segments);
+                this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
+            }
         }
         // Close streaming connection
         if (this.syncManager.pushManager)

package/cjs/readiness/sdkReadinessManager.js

@@ -13,15 +13,13 @@ var REMOVE_LISTENER_EVENT = 'removeListener';
  * It also updates logs related warnings and errors.
  *
  * @param readyTimeout time in millis to emit SDK_READY_TIME_OUT event
- * @param internalReadyCbCount offset value of SDK_READY listeners that are added/removed internally
- * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalReadyCbCount, readinessManager) {
+function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager) {
     if (readyTimeout === void 0) { readyTimeout = 0; }
-    if (internalReadyCbCount === void 0) { internalReadyCbCount = 0; }
     if (readinessManager === void 0) { readinessManager = (0, readinessManager_1.readinessManagerFactory)(EventEmitter, readyTimeout); }
     /** Ready callback warning */
+    var internalReadyCbCount = 0;
     var readyCbCount = 0;
     readinessManager.gate.on(REMOVE_LISTENER_EVENT, function (event) {
         if (event === constants_1.SDK_READY)
@@ -62,10 +60,12 @@ function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalRea
     }
     return {
         readinessManager: readinessManager,
-        shared: function (readyTimeout, internalReadyCbCount) {
+        shared: function (readyTimeout) {
             if (readyTimeout === void 0) { readyTimeout = 0; }
-            if (internalReadyCbCount === void 0) { internalReadyCbCount = 0; }
-            return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalReadyCbCount, readinessManager.shared(readyTimeout));
+            return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));
+        },
+        incInternalReadyCbCount: function () {
+            internalReadyCbCount++;
         },
         sdkStatus: (0, objectAssign_1.objectAssign)(
         // Expose Event Emitter functionality

package/cjs/storages/KeyBuilderSS.js

@@ -20,23 +20,27 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.buildRegisteredSegmentsKey = function () {
         return this.prefix + ".segments.registered";
     };
-    KeyBuilderSS.prototype.buildVersionablePrefix = function () {
-        return this.metadata.s + "/" + this.metadata.n + "/" + this.metadata.i;
-    };
     KeyBuilderSS.prototype.buildImpressionsKey = function () {
         return this.prefix + ".impressions";
     };
     KeyBuilderSS.prototype.buildEventsKey = function () {
         return this.prefix + ".events";
     };
+    KeyBuilderSS.prototype.searchPatternForSplitKeys = function () {
+        return this.buildSplitKeyPrefix() + "*";
+    };
+    /* Telemetry keys */
     KeyBuilderSS.prototype.buildLatencyKey = function (method, bucket) {
         return this.prefix + ".telemetry.latencies::" + this.buildVersionablePrefix() + "/" + methodNames[method] + "/" + bucket;
     };
     KeyBuilderSS.prototype.buildExceptionKey = function (method) {
         return this.prefix + ".telemetry.exceptions::" + this.buildVersionablePrefix() + "/" + methodNames[method];
     };
-    KeyBuilderSS.prototype.searchPatternForSplitKeys = function () {
-        return this.buildSplitKeyPrefix() + "*";
+    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 KeyBuilderSS;
 }(KeyBuilder_1.KeyBuilder));

package/cjs/storages/inRedis/RedisAdapter.js

@@ -9,7 +9,7 @@ var thenable_1 = require("../../utils/promise/thenable");
 var timeout_1 = require("../../utils/promise/timeout");
 var LOG_PREFIX = 'storage:redis-adapter: ';
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim'];
+var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim', 'hset'];
 // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
 var DEFAULT_OPTIONS = {
     connectionTimeout: 10000,

package/cjs/storages/inRedis/TelemetryCacheInRedis.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelemetryCacheInRedis = void 0;
 var findLatencyIndex_1 = require("../findLatencyIndex");
+var telemetrySubmitter_1 = require("../../sync/submitters/telemetrySubmitter");
+var constants_1 = require("../../utils/constants");
 var TelemetryCacheInRedis = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses Redis as storage.
@@ -24,6 +26,11 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         return this.redis.hincrby(key, field, 1)
             .catch(function () { });
     };
+    TelemetryCacheInRedis.prototype.recordConfig = function () {
+        var _a = this.keys.buildInitKey().split('::'), key = _a[0], field = _a[1];
+        var value = JSON.stringify((0, telemetrySubmitter_1.getTelemetryConfigStats)(constants_1.CONSUMER_MODE, constants_1.STORAGE_REDIS));
+        return this.redis.hset(key, field, value).catch(function () { });
+    };
     return TelemetryCacheInRedis;
 }());
 exports.TelemetryCacheInRedis = TelemetryCacheInRedis;

package/cjs/storages/inRedis/index.js

@@ -21,16 +21,19 @@ function InRedisStorage(options) {
         var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb;
         var keys = new KeyBuilderSS_1.KeyBuilderSS(prefix, metadata);
         var redisClient = new RedisAdapter_1.RedisAdapter(log, options.options || {});
+        var telemetry = new TelemetryCacheInRedis_1.TelemetryCacheInRedis(log, keys, redisClient);
         // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
         redisClient.on('connect', function () {
             onReadyCb();
+            // Synchronize config
+            telemetry.recordConfig();
         });
         return {
             splits: new SplitsCacheInRedis_1.SplitsCacheInRedis(log, keys, redisClient),
             segments: new SegmentsCacheInRedis_1.SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis_1.ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
             events: new EventsCacheInRedis_1.EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
-            telemetry: new TelemetryCacheInRedis_1.TelemetryCacheInRedis(log, keys, redisClient),
+            telemetry: telemetry,
             // When using REDIS we should:
             // 1- Disconnect from the storage
             destroy: function () {

package/cjs/storages/pluggable/index.js

@@ -34,6 +34,7 @@ function validatePluggableStorageOptions(options) {
 function wrapperConnect(wrapper, onReadyCb) {
     wrapper.connect().then(function () {
         onReadyCb();
+        // At the moment, we don't synchronize config with pluggable storage
     }).catch(function (e) {
         onReadyCb(e || new Error('Error connecting wrapper'));
     });
@@ -66,7 +67,7 @@ function PluggableStorage(options) {
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable_1.ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
             impressionCounts: optimize ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable_1.EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-            // @TODO Not using TelemetryCachePluggable yet, because it is not supported by the Split Synchronizer
+            // @TODO Not using TelemetryCachePluggable yet because it's not supported by the Split Synchronizer, and needs to drop or queue operations while the wrapper is not ready
             // telemetry: isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper),
             // Disconnect the underlying storage
             destroy: function () {

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -1,13 +1,14 @@
 "use strict";
-var _a, _b;
+var _a, _b, _c;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.telemetrySubmitterFactory = exports.telemetryCacheConfigAdapter = exports.telemetryCacheStatsAdapter = void 0;
+exports.telemetrySubmitterFactory = exports.telemetryCacheConfigAdapter = exports.getTelemetryConfigStats = exports.telemetryCacheStatsAdapter = void 0;
 var submitter_1 = require("./submitter");
 var constants_1 = require("../../utils/constants");
 var constants_2 = require("../../readiness/constants");
 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");
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
  */
@@ -50,6 +51,11 @@ var IMPRESSIONS_MODE_MAP = (_b = {},
     _b[constants_1.OPTIMIZED] = constants_1.OPTIMIZED_ENUM,
     _b[constants_1.DEBUG] = constants_1.DEBUG_ENUM,
     _b);
+var USER_CONSENT_MAP = (_c = {},
+    _c[constants_1.CONSENT_UNKNOWN] = 1,
+    _c[constants_1.CONSENT_GRANTED] = 2,
+    _c[constants_1.CONSENT_DECLINED] = 3,
+    _c);
 function getActiveFactories() {
     return Object.keys(apiKey_1.usedKeysMap).length;
 }
@@ -58,6 +64,15 @@ function getRedundantActiveFactories() {
         return acum + apiKey_1.usedKeysMap[apiKey] - 1;
     }, 0);
 }
+function getTelemetryConfigStats(mode, storageType) {
+    return {
+        oM: OPERATION_MODE_MAP[mode],
+        st: storageType.toLowerCase(),
+        aF: getActiveFactories(),
+        rF: getRedundantActiveFactories(),
+    };
+}
+exports.getTelemetryConfigStats = getTelemetryConfigStats;
 /**
  * Converts data from telemetry cache and settings into /metrics/config request payload.
  */
@@ -67,16 +82,14 @@ function telemetryCacheConfigAdapter(telemetry, settings) {
         clear: function () { },
         state: function () {
             var urls = settings.urls, scheduler = settings.scheduler;
-            return {
-                oM: OPERATION_MODE_MAP[settings.mode],
-                st: settings.storage.type.toLowerCase(),
+            return (0, objectAssign_1.objectAssign)(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
                 rR: {
-                    sp: scheduler.featuresRefreshRate,
-                    se: scheduler.segmentsRefreshRate,
-                    im: scheduler.impressionsRefreshRate,
-                    ev: scheduler.eventsPushRate,
-                    te: scheduler.telemetryRefreshRate,
+                    sp: scheduler.featuresRefreshRate / 1000,
+                    se: scheduler.segmentsRefreshRate / 1000,
+                    im: scheduler.impressionsRefreshRate / 1000,
+                    ev: scheduler.eventsPushRate / 1000,
+                    te: scheduler.telemetryRefreshRate / 1000,
                 },
                 uO: {
                     s: urls.sdk !== settingsValidation_1.base.urls.sdk,
@@ -90,14 +103,13 @@ function telemetryCacheConfigAdapter(telemetry, settings) {
                 iM: IMPRESSIONS_MODE_MAP[settings.sync.impressionsMode],
                 iL: settings.impressionListener ? true : false,
                 hP: false,
-                aF: getActiveFactories(),
-                rF: getRedundantActiveFactories(),
                 tR: telemetry.getTimeUntilReady(),
                 tC: telemetry.getTimeUntilReadyFromCache(),
                 nR: telemetry.getNonReadyUsage(),
                 t: telemetry.popTags(),
                 i: settings.integrations && settings.integrations.map(function (int) { return int.type; }),
-            };
+                uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0
+            });
         }
     };
 }
@@ -109,12 +121,13 @@ function telemetrySubmitterFactory(params) {
     var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry;
     if (!telemetry)
         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, now = params.platform.now, readiness = params.readiness;
+    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, now = params.platform.now, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
     var startTime = (0, timer_1.timer)(now || Date.now);
     var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(constants_2.SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());
     });
+    sdkReadinessManager.incInternalReadyCbCount();
     readiness.gate.once(constants_2.SDK_READY, function () {
         telemetry.recordTimeUntilReady(startTime());
         // Post config data when the SDK is ready and if the telemetry submitter was started

package/cjs/trackers/telemetryTracker.js

@@ -29,7 +29,7 @@ function telemetryTrackerFactory(telemetryCache, now) {
                     if (error && error.statusCode)
                         telemetryCache.recordHttpError(operation, error.statusCode);
                     else
-                        telemetryCache.recordSuccessfulSync(operation, now());
+                        telemetryCache.recordSuccessfulSync(operation, Date.now());
                 };
             },
             sessionLength: function () {
@@ -44,7 +44,7 @@ function telemetryTrackerFactory(telemetryCache, now) {
                     telemetryCache.recordStreamingEvents({
                         e: e,
                         d: d,
-                        t: now()
+                        t: Date.now()
                     });
                     if (e === constants_1.TOKEN_REFRESH)
                         telemetryCache.recordTokenRefreshes();

package/cjs/utils/timeTracker/now/node.js

@@ -5,6 +5,6 @@ exports.now = void 0;
 function now() {
     // eslint-disable-next-line no-undef
     var time = process.hrtime();
-    return time[0] * 1e3 + time[1] * 1e-6; // convert it to milis
+    return time[0] * 1e3 + time[1] * 1e-6; // convert it to millis
 }
 exports.now = now;

package/esm/listeners/browser.js

@@ -4,6 +4,7 @@ import { OPTIMIZED, DEBUG } 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';
 // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
 var UNLOAD_DOM_EVENT = 'unload';
 var EVENT_NAME = 'for unload page event.';
@@ -60,7 +61,11 @@ var BrowserSignalListener = /** @class */ (function () {
             this._flushData(eventsUrl + '/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);
-            // No beacon endpoint for `/metrics/usage`
+            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);
+            }
         }
         // Close streaming connection
         if (this.syncManager.pushManager)

package/esm/readiness/sdkReadinessManager.js

@@ -10,15 +10,13 @@ var REMOVE_LISTENER_EVENT = 'removeListener';
  * It also updates logs related warnings and errors.
  *
  * @param readyTimeout time in millis to emit SDK_READY_TIME_OUT event
- * @param internalReadyCbCount offset value of SDK_READY listeners that are added/removed internally
- * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-export function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalReadyCbCount, readinessManager) {
+export function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager) {
     if (readyTimeout === void 0) { readyTimeout = 0; }
-    if (internalReadyCbCount === void 0) { internalReadyCbCount = 0; }
     if (readinessManager === void 0) { readinessManager = readinessManagerFactory(EventEmitter, readyTimeout); }
     /** Ready callback warning */
+    var internalReadyCbCount = 0;
     var readyCbCount = 0;
     readinessManager.gate.on(REMOVE_LISTENER_EVENT, function (event) {
         if (event === SDK_READY)
@@ -59,10 +57,12 @@ export function sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, inte
     }
     return {
         readinessManager: readinessManager,
-        shared: function (readyTimeout, internalReadyCbCount) {
+        shared: function (readyTimeout) {
             if (readyTimeout === void 0) { readyTimeout = 0; }
-            if (internalReadyCbCount === void 0) { internalReadyCbCount = 0; }
-            return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalReadyCbCount, readinessManager.shared(readyTimeout));
+            return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));
+        },
+        incInternalReadyCbCount: function () {
+            internalReadyCbCount++;
         },
         sdkStatus: objectAssign(
         // Expose Event Emitter functionality

package/esm/storages/KeyBuilderSS.js

@@ -17,23 +17,27 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.buildRegisteredSegmentsKey = function () {
         return this.prefix + ".segments.registered";
     };
-    KeyBuilderSS.prototype.buildVersionablePrefix = function () {
-        return this.metadata.s + "/" + this.metadata.n + "/" + this.metadata.i;
-    };
     KeyBuilderSS.prototype.buildImpressionsKey = function () {
         return this.prefix + ".impressions";
     };
     KeyBuilderSS.prototype.buildEventsKey = function () {
         return this.prefix + ".events";
     };
+    KeyBuilderSS.prototype.searchPatternForSplitKeys = function () {
+        return this.buildSplitKeyPrefix() + "*";
+    };
+    /* Telemetry keys */
     KeyBuilderSS.prototype.buildLatencyKey = function (method, bucket) {
         return this.prefix + ".telemetry.latencies::" + this.buildVersionablePrefix() + "/" + methodNames[method] + "/" + bucket;
     };
     KeyBuilderSS.prototype.buildExceptionKey = function (method) {
         return this.prefix + ".telemetry.exceptions::" + this.buildVersionablePrefix() + "/" + methodNames[method];
     };
-    KeyBuilderSS.prototype.searchPatternForSplitKeys = function () {
-        return this.buildSplitKeyPrefix() + "*";
+    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 KeyBuilderSS;
 }(KeyBuilder));

package/esm/storages/inRedis/RedisAdapter.js

@@ -6,7 +6,7 @@ import { thenable } from '../../utils/promise/thenable';
 import { timeout } from '../../utils/promise/timeout';
 var LOG_PREFIX = 'storage:redis-adapter: ';
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim'];
+var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim', 'hset'];
 // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
 var DEFAULT_OPTIONS = {
     connectionTimeout: 10000,

package/esm/storages/inRedis/TelemetryCacheInRedis.js

@@ -1,4 +1,6 @@
 import { findLatencyIndex } from '../findLatencyIndex';
+import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
+import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
 var TelemetryCacheInRedis = /** @class */ (function () {
     /**
      * Create a Telemetry cache that uses Redis as storage.
@@ -21,6 +23,11 @@ var TelemetryCacheInRedis = /** @class */ (function () {
         return this.redis.hincrby(key, field, 1)
             .catch(function () { });
     };
+    TelemetryCacheInRedis.prototype.recordConfig = function () {
+        var _a = this.keys.buildInitKey().split('::'), key = _a[0], field = _a[1];
+        var value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, STORAGE_REDIS));
+        return this.redis.hset(key, field, value).catch(function () { });
+    };
     return TelemetryCacheInRedis;
 }());
 export { TelemetryCacheInRedis };

package/esm/storages/inRedis/index.js

@@ -18,16 +18,19 @@ export function InRedisStorage(options) {
         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);
         // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
         redisClient.on('connect', function () {
             onReadyCb();
+            // Synchronize config
+            telemetry.recordConfig();
         });
         return {
             splits: new SplitsCacheInRedis(log, keys, redisClient),
             segments: new SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
             events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
-            telemetry: new TelemetryCacheInRedis(log, keys, redisClient),
+            telemetry: telemetry,
             // When using REDIS we should:
             // 1- Disconnect from the storage
             destroy: function () {

package/esm/storages/pluggable/index.js

@@ -31,6 +31,7 @@ function validatePluggableStorageOptions(options) {
 function wrapperConnect(wrapper, onReadyCb) {
     wrapper.connect().then(function () {
         onReadyCb();
+        // At the moment, we don't synchronize config with pluggable storage
     }).catch(function (e) {
         onReadyCb(e || new Error('Error connecting wrapper'));
     });
@@ -63,7 +64,7 @@ export function PluggableStorage(options) {
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
             impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-            // @TODO Not using TelemetryCachePluggable yet, because it is not supported by the Split Synchronizer
+            // @TODO Not using TelemetryCachePluggable yet because it's not supported by the Split Synchronizer, and needs to drop or queue operations while the wrapper is not ready
             // telemetry: isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper),
             // Disconnect the underlying storage
             destroy: function () {

package/esm/sync/submitters/telemetrySubmitter.js

@@ -1,10 +1,11 @@
-var _a, _b;
+var _a, _b, _c;
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM } from '../../utils/constants';
+import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
 import { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
+import { objectAssign } from '../../utils/lang/objectAssign';
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
  */
@@ -46,6 +47,11 @@ var IMPRESSIONS_MODE_MAP = (_b = {},
     _b[OPTIMIZED] = OPTIMIZED_ENUM,
     _b[DEBUG] = DEBUG_ENUM,
     _b);
+var USER_CONSENT_MAP = (_c = {},
+    _c[CONSENT_UNKNOWN] = 1,
+    _c[CONSENT_GRANTED] = 2,
+    _c[CONSENT_DECLINED] = 3,
+    _c);
 function getActiveFactories() {
     return Object.keys(usedKeysMap).length;
 }
@@ -54,6 +60,14 @@ function getRedundantActiveFactories() {
         return acum + usedKeysMap[apiKey] - 1;
     }, 0);
 }
+export function getTelemetryConfigStats(mode, storageType) {
+    return {
+        oM: OPERATION_MODE_MAP[mode],
+        st: storageType.toLowerCase(),
+        aF: getActiveFactories(),
+        rF: getRedundantActiveFactories(),
+    };
+}
 /**
  * Converts data from telemetry cache and settings into /metrics/config request payload.
  */
@@ -63,16 +77,14 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
         clear: function () { },
         state: function () {
             var urls = settings.urls, scheduler = settings.scheduler;
-            return {
-                oM: OPERATION_MODE_MAP[settings.mode],
-                st: settings.storage.type.toLowerCase(),
+            return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
                 rR: {
-                    sp: scheduler.featuresRefreshRate,
-                    se: scheduler.segmentsRefreshRate,
-                    im: scheduler.impressionsRefreshRate,
-                    ev: scheduler.eventsPushRate,
-                    te: scheduler.telemetryRefreshRate,
+                    sp: scheduler.featuresRefreshRate / 1000,
+                    se: scheduler.segmentsRefreshRate / 1000,
+                    im: scheduler.impressionsRefreshRate / 1000,
+                    ev: scheduler.eventsPushRate / 1000,
+                    te: scheduler.telemetryRefreshRate / 1000,
                 },
                 uO: {
                     s: urls.sdk !== base.urls.sdk,
@@ -86,14 +98,13 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
                 iM: IMPRESSIONS_MODE_MAP[settings.sync.impressionsMode],
                 iL: settings.impressionListener ? true : false,
                 hP: false,
-                aF: getActiveFactories(),
-                rF: getRedundantActiveFactories(),
                 tR: telemetry.getTimeUntilReady(),
                 tC: telemetry.getTimeUntilReadyFromCache(),
                 nR: telemetry.getNonReadyUsage(),
                 t: telemetry.popTags(),
                 i: settings.integrations && settings.integrations.map(function (int) { return int.type; }),
-            };
+                uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0
+            });
         }
     };
 }
@@ -104,12 +115,13 @@ export function telemetrySubmitterFactory(params) {
     var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry;
     if (!telemetry)
         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, now = params.platform.now, readiness = params.readiness;
+    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, now = params.platform.now, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
     var startTime = timer(now || Date.now);
     var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());
     });
+    sdkReadinessManager.incInternalReadyCbCount();
     readiness.gate.once(SDK_READY, function () {
         telemetry.recordTimeUntilReady(startTime());
         // Post config data when the SDK is ready and if the telemetry submitter was started

package/esm/trackers/telemetryTracker.js

@@ -26,7 +26,7 @@ export function telemetryTrackerFactory(telemetryCache, now) {
                     if (error && error.statusCode)
                         telemetryCache.recordHttpError(operation, error.statusCode);
                     else
-                        telemetryCache.recordSuccessfulSync(operation, now());
+                        telemetryCache.recordSuccessfulSync(operation, Date.now());
                 };
             },
             sessionLength: function () {
@@ -41,7 +41,7 @@ export function telemetryTrackerFactory(telemetryCache, now) {
                     telemetryCache.recordStreamingEvents({
                         e: e,
                         d: d,
-                        t: now()
+                        t: Date.now()
                     });
                     if (e === TOKEN_REFRESH)
                         telemetryCache.recordTokenRefreshes();

package/esm/utils/timeTracker/now/node.js

@@ -2,5 +2,5 @@
 export function now() {
     // eslint-disable-next-line no-undef
     var time = process.hrtime();
-    return time[0] * 1e3 + time[1] * 1e-6; // convert it to milis
+    return time[0] * 1e3 + time[1] * 1e-6; // convert it to millis
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.3.2-rc.2",
+  "version": "1.3.2-rc.5",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/listeners/browser.ts

@@ -12,6 +12,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { ISyncManager } from '../sync/types';
 import { isConsentGranted } from '../consent';
+import { telemetryCacheStatsAdapter } from '../sync/submitters/telemetrySubmitter';
 
 // 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
 const UNLOAD_DOM_EVENT = 'unload';
@@ -77,7 +78,11 @@ export class BrowserSignalListener implements ISignalListener {
       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);
       if (this.storage.impressionCounts) this._flushData(eventsUrl + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);
-      // No beacon endpoint for `/metrics/usage`
+      if (this.storage.telemetry) {
+        const telemetryUrl = this.settings.urls.telemetry;
+        const telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
+        this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
+      }
     }
 
     // Close streaming connection

package/src/readiness/sdkReadinessManager.ts

@@ -15,18 +15,16 @@ const REMOVE_LISTENER_EVENT = 'removeListener';
  * It also updates logs related warnings and errors.
  *
  * @param readyTimeout time in millis to emit SDK_READY_TIME_OUT event
- * @param internalReadyCbCount offset value of SDK_READY listeners that are added/removed internally
- * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
 export function sdkReadinessManagerFactory(
   log: ILogger,
   EventEmitter: new () => IEventEmitter,
   readyTimeout = 0,
-  internalReadyCbCount = 0,
   readinessManager = readinessManagerFactory(EventEmitter, readyTimeout)): ISdkReadinessManager {
 
   /** Ready callback warning */
+  let internalReadyCbCount = 0;
   let readyCbCount = 0;
   readinessManager.gate.on(REMOVE_LISTENER_EVENT, (event: any) => {
     if (event === SDK_READY) readyCbCount--;
@@ -74,8 +72,12 @@ export function sdkReadinessManagerFactory(
   return {
     readinessManager,
 
-    shared(readyTimeout = 0, internalReadyCbCount = 0) {
-      return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, internalReadyCbCount, readinessManager.shared(readyTimeout));
+    shared(readyTimeout = 0) {
+      return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));
+    },
+
+    incInternalReadyCbCount() {
+      internalReadyCbCount++;
     },
 
     sdkStatus: objectAssign(

package/src/readiness/types.ts

@@ -66,6 +66,12 @@ export interface ISdkReadinessManager {
   readinessManager: IReadinessManager
   sdkStatus: IStatusInterface
 
+  /**
+   * Increment internalReadyCbCount, an offset value of SDK_READY listeners that are added/removed internally
+   * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
+   */
+  incInternalReadyCbCount(): void
+
   /** for client-side */
-  shared(readyTimeout?: number, internalReadyCbCount?: number): ISdkReadinessManager
+  shared(readyTimeout?: number): ISdkReadinessManager
 }

package/src/storages/KeyBuilderSS.ts

@@ -23,10 +23,6 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.segments.registered`;
   }
 
-  private buildVersionablePrefix() {
-    return `${this.metadata.s}/${this.metadata.n}/${this.metadata.i}`;
-  }
-
   buildImpressionsKey() {
     return `${this.prefix}.impressions`;
   }
@@ -35,6 +31,12 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.events`;
   }
 
+  searchPatternForSplitKeys() {
+    return `${this.buildSplitKeyPrefix()}*`;
+  }
+
+  /* Telemetry keys */
+
   buildLatencyKey(method: Method, bucket: number) {
     return `${this.prefix}.telemetry.latencies::${this.buildVersionablePrefix()}/${methodNames[method]}/${bucket}`;
   }
@@ -43,8 +45,12 @@ export class KeyBuilderSS extends KeyBuilder {
     return `${this.prefix}.telemetry.exceptions::${this.buildVersionablePrefix()}/${methodNames[method]}`;
   }
 
-  searchPatternForSplitKeys() {
-    return `${this.buildSplitKeyPrefix()}*`;
+  buildInitKey() {
+    return `${this.prefix}.telemetry.init::${this.buildVersionablePrefix()}`;
+  }
+
+  private buildVersionablePrefix() {
+    return `${this.metadata.s}/${this.metadata.n}/${this.metadata.i}`;
   }
 
 }

package/src/storages/inRedis/RedisAdapter.ts

@@ -8,7 +8,7 @@ import { timeout } from '../../utils/promise/timeout';
 const LOG_PREFIX = 'storage:redis-adapter: ';
 
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
-const METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim'];
+const METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'pipeline', 'expire', 'mget', 'lrange', 'ltrim', 'hset'];
 
 // Not part of the settings since it'll vary on each storage. We should be removing storage specific logic from elsewhere.
 const DEFAULT_OPTIONS = {

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -4,6 +4,8 @@ import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { Redis } from 'ioredis';
+import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
+import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
 
 export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
 
@@ -26,4 +28,9 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
       .catch(() => { /* Handle rejections for telemetry */ });
   }
 
+  recordConfig() {
+    const [key, field] = this.keys.buildInitKey().split('::');
+    const value = JSON.stringify(getTelemetryConfigStats(CONSUMER_MODE, STORAGE_REDIS));
+    return this.redis.hset(key, field, value).catch(() => { /* Handle rejections for telemetry */ });
+  }
 }

package/src/storages/inRedis/index.ts

@@ -26,10 +26,14 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
     const keys = new KeyBuilderSS(prefix, metadata);
     const redisClient = new RedisAdapter(log, options.options || {});
+    const telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
 
     // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
     redisClient.on('connect', () => {
       onReadyCb();
+
+      // Synchronize config
+      telemetry.recordConfig();
     });
 
     return {
@@ -37,7 +41,7 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
       segments: new SegmentsCacheInRedis(log, keys, redisClient),
       impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
       events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
-      telemetry: new TelemetryCacheInRedis(log, keys, redisClient),
+      telemetry,
 
       // When using REDIS we should:
       // 1- Disconnect from the storage

package/src/storages/pluggable/index.ts

@@ -39,6 +39,7 @@ function validatePluggableStorageOptions(options: any) {
 function wrapperConnect(wrapper: IPluggableStorageWrapper, onReadyCb: (error?: any) => void) {
   wrapper.connect().then(() => {
     onReadyCb();
+    // At the moment, we don't synchronize config with pluggable storage
   }).catch((e) => {
     onReadyCb(e || new Error('Error connecting wrapper'));
   });
@@ -77,7 +78,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
       impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
       events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-      // @TODO Not using TelemetryCachePluggable yet, because it is not supported by the Split Synchronizer
+      // @TODO Not using TelemetryCachePluggable yet because it's not supported by the Split Synchronizer, and needs to drop or queue operations while the wrapper is not ready
       // telemetry: isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper),
 
       // Disconnect the underlying storage

package/src/sync/submitters/telemetrySubmitter.ts

@@ -1,13 +1,14 @@
 import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
 import { submitterFactory, firstPushWindowDecorator } from './submitter';
-import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload } from './types';
-import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM } from '../../utils/constants';
+import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
+import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM, CONSENT_GRANTED, CONSENT_DECLINED, CONSENT_UNKNOWN } from '../../utils/constants';
 import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
-import { ISettings } from '../../types';
+import { ConsentStatus, ISettings, SDKMode } from '../../types';
 import { base } from '../../utils/settingsValidation';
 import { usedKeysMap } from '../../utils/inputValidation/apiKey';
 import { timer } from '../../utils/timeTracker/timer';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { objectAssign } from '../../utils/lang/objectAssign';
 
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
@@ -54,6 +55,12 @@ const IMPRESSIONS_MODE_MAP = {
   [DEBUG]: DEBUG_ENUM
 } as Record<ISettings['sync']['impressionsMode'], (0 | 1)>;
 
+const USER_CONSENT_MAP = {
+  [CONSENT_UNKNOWN]: 1,
+  [CONSENT_GRANTED]: 2,
+  [CONSENT_DECLINED]: 3
+} as Record<ConsentStatus, number>;
+
 function getActiveFactories() {
   return Object.keys(usedKeysMap).length;
 }
@@ -64,6 +71,15 @@ function getRedundantActiveFactories() {
   }, 0);
 }
 
+export function getTelemetryConfigStats(mode: SDKMode, storageType: string): TelemetryConfigStats {
+  return {
+    oM: OPERATION_MODE_MAP[mode], // @ts-ignore lower case of storage type
+    st: storageType.toLowerCase(),
+    aF: getActiveFactories(),
+    rF: getRedundantActiveFactories(),
+  };
+}
+
 /**
  * Converts data from telemetry cache and settings into /metrics/config request payload.
  */
@@ -75,16 +91,14 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
     state(): TelemetryConfigStatsPayload {
       const { urls, scheduler } = settings;
 
-      return {
-        oM: OPERATION_MODE_MAP[settings.mode], // @ts-ignore lower case of storage type
-        st: settings.storage.type.toLowerCase(),
+      return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
         sE: settings.streamingEnabled,
         rR: {
-          sp: scheduler.featuresRefreshRate,
-          se: scheduler.segmentsRefreshRate,
-          im: scheduler.impressionsRefreshRate,
-          ev: scheduler.eventsPushRate,
-          te: scheduler.telemetryRefreshRate,
+          sp: scheduler.featuresRefreshRate / 1000,
+          se: scheduler.segmentsRefreshRate / 1000,
+          im: scheduler.impressionsRefreshRate / 1000,
+          ev: scheduler.eventsPushRate / 1000,
+          te: scheduler.telemetryRefreshRate / 1000,
         }, // refreshRates
         uO: {
           s: urls.sdk !== base.urls.sdk,
@@ -98,14 +112,13 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
         iM: IMPRESSIONS_MODE_MAP[settings.sync.impressionsMode],
         iL: settings.impressionListener ? true : false,
         hP: false, // @TODO proxy not supported
-        aF: getActiveFactories(),
-        rF: getRedundantActiveFactories(),
         tR: telemetry.getTimeUntilReady() as number,
         tC: telemetry.getTimeUntilReadyFromCache(),
         nR: telemetry.getNonReadyUsage(),
         t: telemetry.popTags(),
         i: settings.integrations && settings.integrations.map(int => int.type),
-      };
+        uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0
+      });
     }
   };
 }
@@ -117,7 +130,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
   const { storage: { splits, segments, telemetry } } = params;
   if (!telemetry) return; // No submitter created if telemetry cache is not defined
 
-  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, platform: { now }, readiness } = params;
+  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, platform: { now }, readiness, sdkReadinessManager } = params;
   const startTime = timer(now || Date.now);
 
   const submitter = firstPushWindowDecorator(
@@ -129,6 +142,7 @@ export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
     telemetry.recordTimeUntilReadyFromCache(startTime());
   });
 
+  sdkReadinessManager.incInternalReadyCbCount();
   readiness.gate.once(SDK_READY, () => {
     telemetry.recordTimeUntilReady(startTime());
 

package/src/sync/submitters/types.ts

@@ -165,10 +165,17 @@ export type UrlOverrides = {
   t: boolean, // telemetry
 }
 
-// 'metrics/config' JSON request body
-export type TelemetryConfigStatsPayload = {
-  oM?: OperationMode, // operationMode
+// 'telemetry.init' Redis/Pluggable key
+export type TelemetryConfigStats = {
+  oM: OperationMode, // operationMode
   st: 'memory' | 'redis' | 'pluggable' | 'localstorage', // storage
+  aF: number, // activeFactories
+  rF: number, // redundantActiveFactories
+  t?: Array<string>, // tags
+}
+
+// 'metrics/config' JSON request body
+export type TelemetryConfigStatsPayload = TelemetryConfigStats & {
   sE: boolean, // streamingEnabled
   rR: RefreshRates, // refreshRates
   uO: UrlOverrides, // urlOverrides
@@ -177,11 +184,9 @@ export type TelemetryConfigStatsPayload = {
   iM: ImpressionsMode, // impressionsMode
   iL: boolean, // impressionsListenerEnabled
   hP: boolean, // httpProxyDetected
-  aF: number, // activeFactories
-  rF: number, // redundantActiveFactories
   tR: number, // timeUntilSDKReady
   tC?: number, // timeUntilSDKReadyFromCache
   nR: number, // SDKNotReadyUsage
-  t?: Array<string>, // tags
   i?: Array<string>, // integrations
+  uC: number, // userConsent
 }

package/src/trackers/telemetryTracker.ts

@@ -33,7 +33,7 @@ export function telemetryTrackerFactory(
         return (error) => {
           (telemetryCache as ITelemetryCacheSync).recordHttpLatency(operation, httpTime());
           if (error && error.statusCode) (telemetryCache as ITelemetryCacheSync).recordHttpError(operation, error.statusCode);
-          else (telemetryCache as ITelemetryCacheSync).recordSuccessfulSync(operation, now());
+          else (telemetryCache as ITelemetryCacheSync).recordSuccessfulSync(operation, Date.now());
         };
       },
       sessionLength() { // @ts-ignore ITelemetryCacheAsync doesn't implement the method
@@ -44,7 +44,7 @@ export function telemetryTrackerFactory(
           (telemetryCache as ITelemetryCacheSync).recordAuthRejections();
         } else {
           (telemetryCache as ITelemetryCacheSync).recordStreamingEvents({
-            e, d, t: now()
+            e, d, t: Date.now()
           });
           if (e === TOKEN_REFRESH) (telemetryCache as ITelemetryCacheSync).recordTokenRefreshes();
         }

package/src/utils/murmur3/utfx.ts

@@ -8,8 +8,7 @@
 */
 
 export interface utfx {
-  encodeUTF16toUTF8(src: () => number | null, dst: (...args: number[]) => string | undefined): void,
-
+  encodeUTF16toUTF8(src: () => number | null, dst: (...args: number[]) => string | undefined): void
 }
 
 

package/src/utils/timeTracker/now/node.ts

@@ -3,5 +3,5 @@ export function now() {
   // eslint-disable-next-line no-undef
   let time = process.hrtime();
 
-  return time[0] * 1e3 + time[1] * 1e-6; // convert it to milis
+  return time[0] * 1e3 + time[1] * 1e-6; // convert it to millis
 }

package/types/readiness/sdkReadinessManager.d.ts

@@ -6,8 +6,6 @@ import { ILogger } from '../logger/types';
  * It also updates logs related warnings and errors.
  *
  * @param readyTimeout time in millis to emit SDK_READY_TIME_OUT event
- * @param internalReadyCbCount offset value of SDK_READY listeners that are added/removed internally
- * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-export declare function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, internalReadyCbCount?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;
+export declare function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;

package/types/readiness/types.d.ts

@@ -49,7 +49,12 @@ export interface IReadinessManager {
 export interface ISdkReadinessManager {
     readinessManager: IReadinessManager;
     sdkStatus: IStatusInterface;
+    /**
+     * Increment internalReadyCbCount, an offset value of SDK_READY listeners that are added/removed internally
+     * by the SDK. It is required to properly log the warning 'No listeners for SDK Readiness detected'
+     */
+    incInternalReadyCbCount(): void;
     /** for client-side */
-    shared(readyTimeout?: number, internalReadyCbCount?: number): ISdkReadinessManager;
+    shared(readyTimeout?: number): ISdkReadinessManager;
 }
 export {};

package/types/storages/KeyBuilderSS.d.ts

@@ -5,10 +5,11 @@ export declare class KeyBuilderSS extends KeyBuilder {
     protected readonly metadata: IMetadata;
     constructor(prefix: string, metadata: IMetadata);
     buildRegisteredSegmentsKey(): string;
-    private buildVersionablePrefix;
     buildImpressionsKey(): string;
     buildEventsKey(): string;
+    searchPatternForSplitKeys(): string;
     buildLatencyKey(method: Method, bucket: number): string;
     buildExceptionKey(method: Method): string;
-    searchPatternForSplitKeys(): string;
+    buildInitKey(): string;
+    private buildVersionablePrefix;
 }

package/types/storages/inRedis/TelemetryCacheInRedis.d.ts

@@ -16,4 +16,5 @@ export declare class TelemetryCacheInRedis implements ITelemetryCacheAsync {
     constructor(log: ILogger, keys: KeyBuilderSS, redis: Redis);
     recordLatency(method: Method, latencyMs: number): Promise<number | void>;
     recordException(method: Method): Promise<number | void>;
+    recordConfig(): Promise<number | void>;
 }

package/types/sync/submitters/telemetrySubmitter.d.ts

@@ -1,6 +1,6 @@
 import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
-import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload } from './types';
-import { ISettings } from '../../types';
+import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload, TelemetryConfigStats } from './types';
+import { ISettings, SDKMode } from '../../types';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 /**
  * Converts data from telemetry cache into /metrics/usage request payload.
@@ -10,6 +10,7 @@ export declare function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSyn
     clear(): void;
     state(): TelemetryUsageStatsPayload;
 };
+export declare function getTelemetryConfigStats(mode: SDKMode, storageType: string): TelemetryConfigStats;
 /**
  * Converts data from telemetry cache and settings into /metrics/config request payload.
  */

package/types/sync/submitters/types.d.ts

@@ -146,9 +146,14 @@ export declare type UrlOverrides = {
     st: boolean;
     t: boolean;
 };
-export declare type TelemetryConfigStatsPayload = {
-    oM?: OperationMode;
+export declare type TelemetryConfigStats = {
+    oM: OperationMode;
     st: 'memory' | 'redis' | 'pluggable' | 'localstorage';
+    aF: number;
+    rF: number;
+    t?: Array<string>;
+};
+export declare type TelemetryConfigStatsPayload = TelemetryConfigStats & {
     sE: boolean;
     rR: RefreshRates;
     uO: UrlOverrides;
@@ -157,11 +162,9 @@ export declare type TelemetryConfigStatsPayload = {
     iM: ImpressionsMode;
     iL: boolean;
     hP: boolean;
-    aF: number;
-    rF: number;
     tR: number;
     tC?: number;
     nR: number;
-    t?: Array<string>;
     i?: Array<string>;
+    uC: number;
 };