@splitsoftware/splitio-commons 1.3.2-rc.3 → 1.3.2-rc.6

package/CHANGES.txt

@@ -1,3 +1,8 @@
+1.4.0 (May 20, 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/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,16 @@ 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(),
+            var isClientSide = settings.core.key !== undefined;
+            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: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
+                    ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+                    im: scheduler.impressionsRefreshRate / 1000,
+                    ev: scheduler.eventsPushRate / 1000,
+                    te: scheduler.telemetryRefreshRate / 1000,
                 },
                 uO: {
                     s: urls.sdk !== settingsValidation_1.base.urls.sdk,
@@ -90,14 +105,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
+            });
         }
     };
 }
@@ -106,11 +120,11 @@ exports.telemetryCacheConfigAdapter = telemetryCacheConfigAdapter;
  * Submitter that periodically posts telemetry data
  */
 function telemetrySubmitterFactory(params) {
-    var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry;
-    if (!telemetry)
+    var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry, now = params.platform.now;
+    if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, now = params.platform.now, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
-    var startTime = (0, timer_1.timer)(now || Date.now);
+    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
+    var startTime = (0, timer_1.timer)(now);
     var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(constants_2.SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.now = void 0;
-// @TODO migrate to Browser SDK package eventually
+// Can be used on any runtime, since it fallbacks to `Date.now` if `performance.now` is not available
 function nowFactory() {
     // eslint-disable-next-line
     if (typeof performance === 'object' && typeof performance.now === 'function') {

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

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.now = void 0;
-// @TODO migrate to Node SDK package eventually
 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/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,16 @@ 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(),
+            var isClientSide = settings.core.key !== undefined;
+            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: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
+                    ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+                    im: scheduler.impressionsRefreshRate / 1000,
+                    ev: scheduler.eventsPushRate / 1000,
+                    te: scheduler.telemetryRefreshRate / 1000,
                 },
                 uO: {
                     s: urls.sdk !== base.urls.sdk,
@@ -86,14 +100,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
+            });
         }
     };
 }
@@ -101,11 +114,11 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
  * Submitter that periodically posts telemetry data
  */
 export function telemetrySubmitterFactory(params) {
-    var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry;
-    if (!telemetry)
+    var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry, now = params.platform.now;
+    if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, now = params.platform.now, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
-    var startTime = timer(now || Date.now);
+    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
+    var startTime = timer(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());

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

@@ -1,4 +1,4 @@
-// @TODO migrate to Browser SDK package eventually
+// Can be used on any runtime, since it fallbacks to `Date.now` if `performance.now` is not available
 function nowFactory() {
     // eslint-disable-next-line
     if (typeof performance === 'object' && typeof performance.now === 'function') {

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

@@ -1,6 +1,5 @@
-// @TODO migrate to Node SDK package eventually
 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.3",
+  "version": "1.3.2-rc.6",
   "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/sdkFactory/types.ts

@@ -11,13 +11,27 @@ import { SplitIO, ISettings, IEventEmitter } from '../types';
 
 /**
  * Environment related dependencies.
- * These getters are called a fixed number of times per factory instantiation.
  */
 export interface IPlatform {
-  getOptions?: () => object
+  /**
+   * If provided, it is used to retrieve the Fetch API for HTTP requests. Otherwise, the global fetch is used.
+   */
   getFetch?: () => (IFetch | undefined)
+  /**
+   * If provided, it is used to pass additional options to fetch calls.
+   */
+  getOptions?: () => object
+  /**
+   * If provided, it is used to retrieve the EventSource constructor for streaming support.
+   */
   getEventSource?: () => (IEventSourceConstructor | undefined)
+  /**
+   * EventEmitter constructor, like NodeJS.EventEmitter or a polyfill.
+   */
   EventEmitter: new () => IEventEmitter,
+  /**
+   * Function used to track latencies for telemetry.
+   */
   now?: () => number
 }