@splitsoftware/splitio-commons 1.3.2-rc.1 → 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/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/services/splitApi.js

@@ -91,11 +91,11 @@ function splitApiFactory(settings, platform, telemetryTracker) {
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.IMPRESSIONS_COUNT));
         },
         postMetricsConfig: function (body) {
-            var url = urls.telemetry + "/metrics/config";
+            var url = urls.telemetry + "/v1/metrics/config";
             return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(constants_1.TELEMETRY), true);
         },
         postMetricsUsage: function (body) {
-            var url = urls.telemetry + "/metrics/usage";
+            var url = urls.telemetry + "/v1/metrics/usage";
             return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(constants_1.TELEMETRY), true);
         }
     };

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

@@ -6,7 +6,8 @@ var constants_1 = require("../../logger/constants");
 /**
  * Base function to create submitters, such as ImpressionsSubmitter and EventsSubmitter
  */
-function submitterFactory(log, postClient, sourceCache, postRate, dataName, fromCacheToPayload, maxRetries, debugLogs) {
+function submitterFactory(log, postClient, sourceCache, postRate, dataName, fromCacheToPayload, maxRetries, debugLogs // true for telemetry submitters
+) {
     if (maxRetries === void 0) { maxRetries = 0; }
     var retries = 0;
     function postData() {
@@ -24,16 +25,16 @@ function submitterFactory(log, postClient, sourceCache, postRate, dataName, from
             sourceCache.clear(); // we clear the queue if request successes.
         }).catch(function (err) {
             if (!maxRetries) {
-                log.warn(constants_1.SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
+                log[debugLogs ? 'debug' : 'warn'](constants_1.SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
             }
             else if (retries === maxRetries) {
                 retries = 0;
                 sourceCache.clear(); // we clear the queue if request fails after retries.
-                log.warn(constants_1.SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
+                log[debugLogs ? 'debug' : 'warn'](constants_1.SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
             }
             else {
                 retries++;
-                log.warn(constants_1.SUBMITTERS_PUSH_RETRY, [dataCountMessage, err]);
+                log[debugLogs ? 'debug' : 'warn'](constants_1.SUBMITTERS_PUSH_RETRY, [dataCountMessage, err]);
             }
         });
     }

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
+            });
         }
     };
 }
@@ -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/utils/settingsValidation/index.js

@@ -32,8 +32,8 @@ exports.base = {
         segmentsRefreshRate: 60,
         // publish telemetry stats each 3600 secs (1 hour)
         telemetryRefreshRate: 3600,
-        // publish evaluations each 60 sec
-        impressionsRefreshRate: 60,
+        // publish evaluations each 300 sec (default value for OPTIMIZED impressions mode)
+        impressionsRefreshRate: 300,
         // fetch offline changes each 15 sec
         offlineRefreshRate: 15,
         // publish events every 60 seconds after the first flush
@@ -55,7 +55,7 @@ exports.base = {
         // Streaming Server
         streaming: 'https://streaming.split.io',
         // Telemetry Server
-        telemetry: 'https://telemetry.split.io',
+        telemetry: 'https://telemetry.split.io/api',
     },
     // Defines which kind of storage we should instanciate.
     storage: undefined,
@@ -96,6 +96,8 @@ function settingsValidation(config, validationParams) {
     // First thing to validate, since other validators might use the logger.
     var log = logger(withDefaults); // @ts-ignore, modify readonly prop
     withDefaults.log = log;
+    // ensure a valid impressionsMode
+    withDefaults.sync.impressionsMode = (0, impressionsMode_1.validImpressionsMode)(log, withDefaults.sync.impressionsMode);
     function validateMinValue(paramName, actualValue, minValue) {
         if (actualValue >= minValue)
             return actualValue;
@@ -107,10 +109,20 @@ function settingsValidation(config, validationParams) {
     var scheduler = withDefaults.scheduler, startup = withDefaults.startup;
     scheduler.featuresRefreshRate = fromSecondsToMillis(scheduler.featuresRefreshRate);
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
-    scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
     scheduler.offlineRefreshRate = fromSecondsToMillis(scheduler.offlineRefreshRate);
     scheduler.eventsPushRate = fromSecondsToMillis(scheduler.eventsPushRate);
     scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
+    if (scheduler.impressionsRefreshRate !== exports.base.scheduler.impressionsRefreshRate) {
+        // Validate impressionsRefreshRate defined by user
+        scheduler.impressionsRefreshRate = validateMinValue('impressionsRefreshRate', scheduler.impressionsRefreshRate, withDefaults.sync.impressionsMode === constants_1.DEBUG ? 1 : 60 // Min is 1 sec for DEBUG and 60 secs for OPTIMIZED
+        );
+    }
+    else {
+        // Default impressionsRefreshRate for DEBUG mode is 60 secs
+        if (withDefaults.sync.impressionsMode === constants_1.DEBUG)
+            scheduler.impressionsRefreshRate = 60;
+    }
+    scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
     // Log deprecation for old telemetry param
     if (scheduler.metricsRefreshRate)
         log.warn('`metricsRefreshRate` will be deprecated soon. For configuring telemetry rates, update `telemetryRefreshRate` value in configs');
@@ -166,8 +178,6 @@ function settingsValidation(config, validationParams) {
     var splitFiltersValidation = (0, splitFilters_1.validateSplitFilters)(log, withDefaults.sync.splitFilters, withDefaults.mode);
     withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
     withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
-    // ensure a valid impressionsMode
-    withDefaults.sync.impressionsMode = (0, impressionsMode_1.validImpressionsMode)(log, withDefaults.sync.impressionsMode);
     // ensure a valid user consent value
     // @ts-ignore, modify readonly prop
     withDefaults.userConsent = consent(withDefaults);

package/cjs/utils/settingsValidation/url.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.url = void 0;
-var telemetryEndpointMatcher = /^\/metrics\/(config|usage)/;
+var telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 var authEndpointMatcher = /^\/v2\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;

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/services/splitApi.js

@@ -88,11 +88,11 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
         },
         postMetricsConfig: function (body) {
-            var url = urls.telemetry + "/metrics/config";
+            var url = urls.telemetry + "/v1/metrics/config";
             return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(TELEMETRY), true);
         },
         postMetricsUsage: function (body) {
-            var url = urls.telemetry + "/metrics/usage";
+            var url = urls.telemetry + "/v1/metrics/usage";
             return splitHttpClient(url, { method: 'POST', body: body }, telemetryTracker.trackHttp(TELEMETRY), true);
         }
     };

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

@@ -3,7 +3,8 @@ import { SUBMITTERS_PUSH, SUBMITTERS_PUSH_FAILS, SUBMITTERS_PUSH_RETRY } from '.
 /**
  * Base function to create submitters, such as ImpressionsSubmitter and EventsSubmitter
  */
-export function submitterFactory(log, postClient, sourceCache, postRate, dataName, fromCacheToPayload, maxRetries, debugLogs) {
+export function submitterFactory(log, postClient, sourceCache, postRate, dataName, fromCacheToPayload, maxRetries, debugLogs // true for telemetry submitters
+) {
     if (maxRetries === void 0) { maxRetries = 0; }
     var retries = 0;
     function postData() {
@@ -21,16 +22,16 @@ export function submitterFactory(log, postClient, sourceCache, postRate, dataNam
             sourceCache.clear(); // we clear the queue if request successes.
         }).catch(function (err) {
             if (!maxRetries) {
-                log.warn(SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
+                log[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
             }
             else if (retries === maxRetries) {
                 retries = 0;
                 sourceCache.clear(); // we clear the queue if request fails after retries.
-                log.warn(SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
+                log[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
             }
             else {
                 retries++;
-                log.warn(SUBMITTERS_PUSH_RETRY, [dataCountMessage, err]);
+                log[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_RETRY, [dataCountMessage, err]);
             }
         });
     }