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

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,9 +82,7 @@ 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,
@@ -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
+            });
         }
     };
 }

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,9 +77,7 @@ 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,
@@ -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
+            });
         }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.3.2-rc.3",
+  "version": "1.3.2-rc.4",
   "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/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, (0 | 1 | 2 | 3)>;
+
 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,9 +91,7 @@ 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,
@@ -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
+      });
     }
   };
 }

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/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/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;
 };