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

package/cjs/sync/submitters/submitter.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstPushWindowDecorator = exports.submitterFactory = void 0;
+var syncTask_1 = require("../syncTask");
+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 // true for telemetry submitters
+) {
+    if (maxRetries === void 0) { maxRetries = 0; }
+    var retries = 0;
+    function postData() {
+        if (sourceCache.isEmpty())
+            return Promise.resolve();
+        var data = sourceCache.state();
+        // @ts-ignore
+        var dataCountMessage = typeof data.length === 'number' ? data.length + " " + dataName : dataName;
+        log[debugLogs ? 'debug' : 'info'](constants_1.SUBMITTERS_PUSH, [dataCountMessage]);
+        var jsonPayload = JSON.stringify(fromCacheToPayload ? fromCacheToPayload(data) : data);
+        if (!maxRetries)
+            sourceCache.clear();
+        return postClient(jsonPayload).then(function () {
+            retries = 0;
+            sourceCache.clear(); // we clear the queue if request successes.
+        }).catch(function (err) {
+            if (!maxRetries) {
+                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[debugLogs ? 'debug' : 'warn'](constants_1.SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
+            }
+            else {
+                retries++;
+                log[debugLogs ? 'debug' : 'warn'](constants_1.SUBMITTERS_PUSH_RETRY, [dataCountMessage, err]);
+            }
+        });
+    }
+    return (0, syncTask_1.syncTaskFactory)(log, postData, postRate, dataName + ' submitter');
+}
+exports.submitterFactory = submitterFactory;
+/**
+ * Decorates a provided submitter with a first execution window
+ */
+function firstPushWindowDecorator(submitter, firstPushWindow) {
+    var running = false;
+    var stopEventPublisherTimeout;
+    var originalStart = submitter.start;
+    submitter.start = function () {
+        running = true;
+        stopEventPublisherTimeout = setTimeout(originalStart, firstPushWindow);
+    };
+    var originalStop = submitter.stop;
+    submitter.stop = function () {
+        running = false;
+        clearTimeout(stopEventPublisherTimeout);
+        originalStop();
+    };
+    submitter.isRunning = function () {
+        return running;
+    };
+    return submitter;
+}
+exports.firstPushWindowDecorator = firstPushWindowDecorator;

package/cjs/sync/submitters/submitterManager.js

@@ -2,19 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.submitterManagerFactory = void 0;
 var syncTaskComposite_1 = require("../syncTaskComposite");
-var eventsSyncTask_1 = require("./eventsSyncTask");
-var impressionsSyncTask_1 = require("./impressionsSyncTask");
-var impressionCountsSyncTask_1 = require("./impressionCountsSyncTask");
+var eventsSubmitter_1 = require("./eventsSubmitter");
+var impressionsSubmitter_1 = require("./impressionsSubmitter");
+var impressionCountsSubmitter_1 = require("./impressionCountsSubmitter");
+var telemetrySubmitter_1 = require("./telemetrySubmitter");
 function submitterManagerFactory(params) {
-    var settings = params.settings, storage = params.storage, splitApi = params.splitApi;
-    var log = settings.log;
     var submitters = [
-        (0, impressionsSyncTask_1.impressionsSyncTaskFactory)(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),
-        (0, eventsSyncTask_1.eventsSyncTaskFactory)(log, splitApi.postEventsBulk, storage.events, settings.scheduler.eventsPushRate, settings.startup.eventsFirstPushWindow)
-        // @TODO add telemetry submitter
+        (0, impressionsSubmitter_1.impressionsSubmitterFactory)(params),
+        (0, eventsSubmitter_1.eventsSubmitterFactory)(params)
     ];
-    if (storage.impressionCounts)
-        submitters.push((0, impressionCountsSyncTask_1.impressionCountsSyncTaskFactory)(log, splitApi.postTestImpressionsCount, storage.impressionCounts));
+    var impressionCountsSubmitter = (0, impressionCountsSubmitter_1.impressionCountsSubmitterFactory)(params);
+    if (impressionCountsSubmitter)
+        submitters.push(impressionCountsSubmitter);
+    var telemetrySubmitter = (0, telemetrySubmitter_1.telemetrySubmitterFactory)(params);
+    if (telemetrySubmitter)
+        submitters.push(telemetrySubmitter);
     return (0, syncTaskComposite_1.syncTaskComposite)(submitters);
 }
 exports.submitterManagerFactory = submitterManagerFactory;

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -0,0 +1,128 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetrySubmitterFactory = exports.telemetryCacheConfigAdapter = 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");
+/**
+ * Converts data from telemetry cache into /metrics/usage request payload.
+ */
+function telemetryCacheStatsAdapter(telemetry, splits, segments) {
+    return {
+        isEmpty: function () { return false; },
+        clear: function () { },
+        // @TODO consider moving inside telemetry cache for code size reduction
+        state: function () {
+            return {
+                lS: telemetry.getLastSynchronization(),
+                mL: telemetry.popLatencies(),
+                mE: telemetry.popExceptions(),
+                hE: telemetry.popHttpErrors(),
+                hL: telemetry.popHttpLatencies(),
+                tR: telemetry.popTokenRefreshes(),
+                aR: telemetry.popAuthRejections(),
+                iQ: telemetry.getImpressionStats(constants_1.QUEUED),
+                iDe: telemetry.getImpressionStats(constants_1.DEDUPED),
+                iDr: telemetry.getImpressionStats(constants_1.DROPPED),
+                spC: splits.getSplitNames().length,
+                seC: segments.getRegisteredSegments().length,
+                skC: segments.getKeysCount(),
+                sL: telemetry.getSessionLength(),
+                eQ: telemetry.getEventStats(constants_1.QUEUED),
+                eD: telemetry.getEventStats(constants_1.DROPPED),
+                sE: telemetry.popStreamingEvents(),
+                t: telemetry.popTags(),
+            };
+        }
+    };
+}
+exports.telemetryCacheStatsAdapter = telemetryCacheStatsAdapter;
+var OPERATION_MODE_MAP = (_a = {},
+    _a[constants_1.STANDALONE_MODE] = constants_1.STANDALONE_ENUM,
+    _a[constants_1.CONSUMER_MODE] = constants_1.CONSUMER_ENUM,
+    _a[constants_1.CONSUMER_PARTIAL_MODE] = constants_1.CONSUMER_PARTIAL_ENUM,
+    _a);
+var IMPRESSIONS_MODE_MAP = (_b = {},
+    _b[constants_1.OPTIMIZED] = constants_1.OPTIMIZED_ENUM,
+    _b[constants_1.DEBUG] = constants_1.DEBUG_ENUM,
+    _b);
+function getActiveFactories() {
+    return Object.keys(apiKey_1.usedKeysMap).length;
+}
+function getRedundantActiveFactories() {
+    return Object.keys(apiKey_1.usedKeysMap).reduce(function (acum, apiKey) {
+        return acum + apiKey_1.usedKeysMap[apiKey] - 1;
+    }, 0);
+}
+/**
+ * Converts data from telemetry cache and settings into /metrics/config request payload.
+ */
+function telemetryCacheConfigAdapter(telemetry, settings) {
+    return {
+        isEmpty: function () { return false; },
+        clear: function () { },
+        state: function () {
+            var urls = settings.urls, scheduler = settings.scheduler;
+            return {
+                oM: OPERATION_MODE_MAP[settings.mode],
+                st: settings.storage.type.toLowerCase(),
+                sE: settings.streamingEnabled,
+                rR: {
+                    sp: scheduler.featuresRefreshRate,
+                    se: scheduler.segmentsRefreshRate,
+                    im: scheduler.impressionsRefreshRate,
+                    ev: scheduler.eventsPushRate,
+                    te: scheduler.telemetryRefreshRate,
+                },
+                uO: {
+                    s: urls.sdk !== settingsValidation_1.base.urls.sdk,
+                    e: urls.events !== settingsValidation_1.base.urls.events,
+                    a: urls.auth !== settingsValidation_1.base.urls.auth,
+                    st: urls.streaming !== settingsValidation_1.base.urls.streaming,
+                    t: urls.telemetry !== settingsValidation_1.base.urls.telemetry,
+                },
+                iQ: scheduler.impressionsQueueSize,
+                eQ: scheduler.eventsQueueSize,
+                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; }),
+            };
+        }
+    };
+}
+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)
+        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 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());
+    });
+    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
+        if (submitter.isRunning()) {
+            var postMetricsConfigTask = (0, submitter_1.submitterFactory)(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, 'telemetry config', undefined, 0, true);
+            postMetricsConfigTask.execute();
+        }
+    });
+    return submitter;
+}
+exports.telemetrySubmitterFactory = telemetrySubmitterFactory;

package/cjs/sync/syncManagerOnline.js

@@ -5,6 +5,7 @@ var submitterManager_1 = require("./submitters/submitterManager");
 var constants_1 = require("./streaming/constants");
 var constants_2 = require("../logger/constants");
 var consent_1 = require("../consent");
+var constants_3 = require("../utils/constants");
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -18,7 +19,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
      * SyncManager factory for modular SDK
      */
     return function (params) {
-        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled;
+        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, telemetryTracker = params.telemetryTracker;
         /** Polling Manager */
         var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
@@ -36,13 +37,16 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
             else {
                 log.info(constants_2.SYNC_START_POLLING);
                 pollingManager.start();
+                telemetryTracker.streamingEvent(constants_3.SYNC_MODE_UPDATE, constants_3.POLLING);
             }
         }
         function stopPollingAndSyncAll() {
             log.info(constants_2.SYNC_STOP_POLLING);
             // if polling, stop
-            if (pollingManager.isRunning())
+            if (pollingManager.isRunning()) {
                 pollingManager.stop();
+                telemetryTracker.streamingEvent(constants_3.SYNC_MODE_UPDATE, constants_3.STREAMING);
+            }
             // fetch splits and segments. There is no need to catch this promise (it is always resolved)
             pollingManager.syncAll();
         }

package/cjs/trackers/eventTracker.js

@@ -12,7 +12,7 @@ var utils_1 = require("./impressionObserver/utils");
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-function eventTrackerFactory(settings, eventsCache, integrationsManager) {
+function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
     var log = settings.log;
     var isSync = (0, utils_1.isStorageSync)(settings);
     function queueEventsCallback(eventData, tracked) {
@@ -48,6 +48,10 @@ function eventTrackerFactory(settings, eventsCache, integrationsManager) {
                 return tracked.then(queueEventsCallback.bind(null, eventData));
             }
             else {
+                // Record when eventsCache is sync only (standalone mode)
+                // @TODO we are not dropping events on full queue yet, so `tracked` is always true ATM
+                if (telemetryCache)
+                    telemetryCache.recordEventStats(tracked ? constants_2.QUEUED : constants_2.DROPPED, 1);
                 return queueEventsCallback(eventData, tracked);
             }
         }

package/cjs/trackers/impressionsTracker.js

@@ -20,7 +20,7 @@ function impressionsTrackerFactory(settings, impressionsCache, integrationsManag
 // if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
 observer, 
 // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
-countsCache) {
+countsCache, telemetryCache) {
     var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
@@ -53,6 +53,14 @@ countsCache) {
                     log.error(constants_1.ERROR_IMPRESSIONS_TRACKER, [impressionsCount, err]);
                 });
             }
+            else {
+                // Record when impressionsCache is sync only (standalone mode)
+                // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
+                if (telemetryCache) {
+                    telemetryCache.recordImpressionStats(constants_2.QUEUED, impressionsToStore.length);
+                    telemetryCache.recordImpressionStats(constants_2.DEDUPED, impressions.length - impressionsToStore.length);
+                }
+            }
             // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor
             if (impressionListener || integrationsManager) {
                 var _loop_1 = function (i) {

package/cjs/trackers/telemetryTracker.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetryTrackerFactory = void 0;
+var labels_1 = require("../utils/labels");
+var timer_1 = require("../utils/timeTracker/timer");
+var constants_1 = require("../utils/constants");
+function telemetryTrackerFactory(telemetryCache, now) {
+    if (telemetryCache && now) {
+        var startTime_1 = (0, timer_1.timer)(now);
+        return {
+            trackEval: function (method) {
+                var evalTime = (0, timer_1.timer)(now);
+                return function (label) {
+                    switch (label) {
+                        case labels_1.EXCEPTION:
+                            telemetryCache.recordException(method);
+                            return; // Don't track latency on exceptions
+                        case labels_1.SDK_NOT_READY: // @ts-ignore ITelemetryCacheAsync doesn't implement the method
+                            if (telemetryCache.recordNonReadyUsage)
+                                telemetryCache.recordNonReadyUsage();
+                    }
+                    telemetryCache.recordLatency(method, evalTime());
+                };
+            },
+            trackHttp: function (operation) {
+                var httpTime = (0, timer_1.timer)(now);
+                return function (error) {
+                    telemetryCache.recordHttpLatency(operation, httpTime());
+                    if (error && error.statusCode)
+                        telemetryCache.recordHttpError(operation, error.statusCode);
+                    else
+                        telemetryCache.recordSuccessfulSync(operation, now());
+                };
+            },
+            sessionLength: function () {
+                if (telemetryCache.recordSessionLength)
+                    telemetryCache.recordSessionLength(startTime_1());
+            },
+            streamingEvent: function (e, d) {
+                if (e === constants_1.AUTH_REJECTION) {
+                    telemetryCache.recordAuthRejections();
+                }
+                else {
+                    telemetryCache.recordStreamingEvents({
+                        e: e,
+                        d: d,
+                        t: now()
+                    });
+                    if (e === constants_1.TOKEN_REFRESH)
+                        telemetryCache.recordTokenRefreshes();
+                }
+            }
+        };
+    }
+    else { // If there is not `telemetryCache` or `now` time tracker, return a no-op telemetry tracker
+        var noopTrack = function () { return function () { }; };
+        return {
+            trackEval: noopTrack,
+            trackHttp: noopTrack,
+            sessionLength: function () { },
+            streamingEvent: function () { },
+        };
+    }
+}
+exports.telemetryTrackerFactory = telemetryTrackerFactory;

package/cjs/utils/constants/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONSENT_UNKNOWN = exports.CONSENT_DECLINED = exports.CONSENT_GRANTED = exports.STORAGE_PLUGGABLE = exports.STORAGE_REDIS = exports.STORAGE_LOCALSTORAGE = exports.STORAGE_MEMORY = exports.CONSUMER_PARTIAL_MODE = exports.CONSUMER_MODE = exports.PRODUCER_MODE = exports.STANDALONE_MODE = exports.LOCALHOST_MODE = exports.OPTIMIZED = exports.DEBUG = exports.SPLIT_EVENT = exports.SPLIT_IMPRESSION = exports.NA = exports.UNKNOWN = exports.CONTROL_WITH_CONFIG = exports.CONTROL = void 0;
+exports.AUTH_REJECTION = exports.SYNC_MODE_UPDATE = exports.ABLY_ERROR = exports.TOKEN_REFRESH = exports.SSE_CONNECTION_ERROR = exports.STREAMING_STATUS = exports.OCCUPANCY_SEC = exports.OCCUPANCY_PRI = exports.CONNECTION_ESTABLISHED = exports.TRACK = exports.TREATMENTS_WITH_CONFIG = exports.TREATMENT_WITH_CONFIG = exports.TREATMENTS = exports.TREATMENT = exports.MY_SEGMENT = exports.SEGMENT = exports.TOKEN = exports.TELEMETRY = exports.EVENTS = exports.IMPRESSIONS_COUNT = exports.IMPRESSIONS = exports.SPLITS = exports.DEBUG_ENUM = exports.OPTIMIZED_ENUM = exports.CONSUMER_PARTIAL_ENUM = exports.CONSUMER_ENUM = exports.STANDALONE_ENUM = exports.DEDUPED = exports.DROPPED = exports.QUEUED = exports.CONSENT_UNKNOWN = exports.CONSENT_DECLINED = exports.CONSENT_GRANTED = exports.STORAGE_PLUGGABLE = exports.STORAGE_REDIS = exports.STORAGE_LOCALSTORAGE = exports.STORAGE_MEMORY = exports.CONSUMER_PARTIAL_MODE = exports.CONSUMER_MODE = exports.PRODUCER_MODE = exports.STANDALONE_MODE = exports.LOCALHOST_MODE = exports.OPTIMIZED = exports.DEBUG = exports.SPLIT_EVENT = exports.SPLIT_IMPRESSION = exports.NA = exports.UNKNOWN = exports.CONTROL_WITH_CONFIG = exports.CONTROL = void 0;
+exports.PAUSED = exports.ENABLED = exports.DISABLED = exports.NON_REQUESTED = exports.REQUESTED = exports.POLLING = exports.STREAMING = void 0;
 // Special treatments
 exports.CONTROL = 'control';
 exports.CONTROL_WITH_CONFIG = {
@@ -31,3 +32,41 @@ exports.STORAGE_PLUGGABLE = 'PLUGGABLE';
 exports.CONSENT_GRANTED = 'GRANTED'; // The user has granted consent for tracking events and impressions
 exports.CONSENT_DECLINED = 'DECLINED'; // The user has declined consent for tracking events and impressions
 exports.CONSENT_UNKNOWN = 'UNKNOWN'; // The user has neither granted nor declined consent for tracking events and impressions
+// Telemetry
+exports.QUEUED = 0;
+exports.DROPPED = 1;
+exports.DEDUPED = 2;
+exports.STANDALONE_ENUM = 0;
+exports.CONSUMER_ENUM = 1;
+exports.CONSUMER_PARTIAL_ENUM = 2;
+exports.OPTIMIZED_ENUM = 0;
+exports.DEBUG_ENUM = 1;
+exports.SPLITS = 'sp';
+exports.IMPRESSIONS = 'im';
+exports.IMPRESSIONS_COUNT = 'ic';
+exports.EVENTS = 'ev';
+exports.TELEMETRY = 'te';
+exports.TOKEN = 'to';
+exports.SEGMENT = 'se';
+exports.MY_SEGMENT = 'ms';
+exports.TREATMENT = 't';
+exports.TREATMENTS = 'ts';
+exports.TREATMENT_WITH_CONFIG = 'tc';
+exports.TREATMENTS_WITH_CONFIG = 'tcs';
+exports.TRACK = 'tr';
+exports.CONNECTION_ESTABLISHED = 0;
+exports.OCCUPANCY_PRI = 10;
+exports.OCCUPANCY_SEC = 20;
+exports.STREAMING_STATUS = 30;
+exports.SSE_CONNECTION_ERROR = 40;
+exports.TOKEN_REFRESH = 50;
+exports.ABLY_ERROR = 60;
+exports.SYNC_MODE_UPDATE = 70;
+exports.AUTH_REJECTION = 80;
+exports.STREAMING = 0;
+exports.POLLING = 1;
+exports.REQUESTED = 0;
+exports.NON_REQUESTED = 1;
+exports.DISABLED = 0;
+exports.ENABLED = 1;
+exports.PAUSED = 2;

package/cjs/utils/inputValidation/apiKey.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
+exports.releaseApiKey = exports.validateAndTrackApiKey = exports.usedKeysMap = exports.validateApiKey = void 0;
 var constants_1 = require("../../logger/constants");
 var lang_1 = require("../lang");
 var item = 'api_key';
@@ -22,31 +22,32 @@ function validateApiKey(log, maybeApiKey) {
     return apiKey;
 }
 exports.validateApiKey = validateApiKey;
-var usedKeysMap = {};
+// Exported for telemetry
+exports.usedKeysMap = {};
 /** validates the given api key and also warns if it is in use */
 function validateAndTrackApiKey(log, maybeApiKey) {
     var apiKey = validateApiKey(log, maybeApiKey);
     // If the apiKey is correct, we'll save it as the instance creation should work.
     if (apiKey) {
-        if (!usedKeysMap[apiKey]) {
+        if (!exports.usedKeysMap[apiKey]) {
             // If this key is not present, only warning scenarios is that we have factories for other keys.
-            usedKeysMap[apiKey] = 1;
-            if (Object.keys(usedKeysMap).length > 1) {
+            exports.usedKeysMap[apiKey] = 1;
+            if (Object.keys(exports.usedKeysMap).length > 1) {
                 log.warn(constants_1.WARN_API_KEY, ['an instance of the Split factory']);
             }
         }
         else {
-            log.warn(constants_1.WARN_API_KEY, [usedKeysMap[apiKey] + " factory/ies with this API Key"]);
-            usedKeysMap[apiKey]++;
+            log.warn(constants_1.WARN_API_KEY, [exports.usedKeysMap[apiKey] + " factory/ies with this API Key"]);
+            exports.usedKeysMap[apiKey]++;
         }
     }
     return apiKey;
 }
 exports.validateAndTrackApiKey = validateAndTrackApiKey;
 function releaseApiKey(apiKey) {
-    if (usedKeysMap[apiKey])
-        usedKeysMap[apiKey]--;
-    if (usedKeysMap[apiKey] === 0)
-        delete usedKeysMap[apiKey];
+    if (exports.usedKeysMap[apiKey])
+        exports.usedKeysMap[apiKey]--;
+    if (exports.usedKeysMap[apiKey] === 0)
+        delete exports.usedKeysMap[apiKey];
 }
 exports.releaseApiKey = releaseApiKey;

package/cjs/utils/settingsValidation/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.settingsValidation = void 0;
+exports.settingsValidation = exports.base = void 0;
 var lang_1 = require("../lang");
 var mode_1 = require("./mode");
 var splitFilters_1 = require("./splitFilters");
@@ -8,7 +8,9 @@ var constants_1 = require("../constants");
 var impressionsMode_1 = require("./impressionsMode");
 var key_1 = require("../inputValidation/key");
 var trafficType_1 = require("../inputValidation/trafficType");
-var base = {
+var constants_2 = require("../../logger/constants");
+// Exported for telemetry
+exports.base = {
     // Define which kind of object you want to retrieve from SplitFactory
     mode: constants_1.STANDALONE_MODE,
     core: {
@@ -28,10 +30,10 @@ var base = {
         featuresRefreshRate: 30,
         // fetch segments updates each 60 sec
         segmentsRefreshRate: 60,
-        // publish metrics each 120 sec
-        metricsRefreshRate: 120,
-        // publish evaluations each 60 sec
-        impressionsRefreshRate: 60,
+        // publish telemetry stats each 3600 secs (1 hour)
+        telemetryRefreshRate: 3600,
+        // 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
@@ -52,6 +54,8 @@ var base = {
         auth: 'https://auth.split.io/api',
         // Streaming Server
         streaming: 'https://streaming.split.io',
+        // Telemetry Server
+        telemetry: 'https://telemetry.split.io/api',
     },
     // Defines which kind of storage we should instanciate.
     storage: undefined,
@@ -87,19 +91,41 @@ function fromSecondsToMillis(n) {
 function settingsValidation(config, validationParams) {
     var defaults = validationParams.defaults, runtime = validationParams.runtime, storage = validationParams.storage, integrations = validationParams.integrations, logger = validationParams.logger, localhost = validationParams.localhost, consent = validationParams.consent;
     // creates a settings object merging base, defaults and config objects.
-    var withDefaults = (0, lang_1.merge)({}, base, defaults, config);
+    var withDefaults = (0, lang_1.merge)({}, exports.base, defaults, config);
     // ensure a valid logger.
     // 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;
+        // actualValue is not a number or is lower than minValue
+        log.error(constants_2.ERROR_MIN_CONFIG_PARAM, [paramName, minValue]);
+        return minValue;
+    }
     // Scheduler periods
     var scheduler = withDefaults.scheduler, startup = withDefaults.startup;
     scheduler.featuresRefreshRate = fromSecondsToMillis(scheduler.featuresRefreshRate);
     scheduler.segmentsRefreshRate = fromSecondsToMillis(scheduler.segmentsRefreshRate);
-    scheduler.metricsRefreshRate = fromSecondsToMillis(scheduler.metricsRefreshRate);
-    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');
     // Startup periods
     startup.requestTimeoutBeforeReady = fromSecondsToMillis(startup.requestTimeoutBeforeReady);
     startup.readyTimeout = fromSecondsToMillis(startup.readyTimeout);
@@ -152,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,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.url = void 0;
+var telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 var authEndpointMatcher = /^\/v2\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;
@@ -13,6 +14,9 @@ var streamingEndpointMatcher = /^\/(sse|event-stream)/;
  * @return complete url
  */
 function url(settings, target) {
+    if (telemetryEndpointMatcher.test(target)) {
+        return "" + settings.urls.telemetry + target;
+    }
     if (eventsEndpointMatcher.test(target)) {
         return "" + settings.urls.events + target;
     }

package/cjs/utils/timeTracker/index.js

@@ -125,6 +125,7 @@ exports.TrackerAPI = {
      * @return {Function | Promise} The stop function for this specific task or the promise received with the callbacks registered.
      */
     start: function (log, task, collectors, promise, now) {
+        if (now === void 0) { now = Date.now; }
         var taskUniqueId = (0, lang_1.uniqueId)();
         var taskCollector = getCollectorForTask(task, collectors);
         var result;

package/cjs/utils/timeTracker/timer.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.timer = void 0;
 function timer(now) {
-    var st = now ? now() : Date.now();
+    var st = now();
     return function stop() {
-        return Math.round(now ? now() : Date.now() - st);
+        return Math.round(now() - st);
     };
 }
 exports.timer = timer;

package/esm/consent/sdkUserConsent.js

@@ -20,7 +20,7 @@ export function createUserConsentAPI(params) {
             var _a, _b;
             // validate input param
             if (!isBoolean(consent)) {
-                log.warn(ERROR_NOT_BOOLEAN, ['setUserConsent']);
+                log.warn(ERROR_NOT_BOOLEAN, ['UserConsent.setStatus']);
                 return false;
             }
             var newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;

package/esm/listeners/browser.js

@@ -1,5 +1,5 @@
-import { fromImpressionsCollector } from '../sync/submitters/impressionsSyncTask';
-import { fromImpressionCountsCollector } from '../sync/submitters/impressionCountsSyncTask';
+import { fromImpressionsCollector } from '../sync/submitters/impressionsSubmitter';
+import { fromImpressionCountsCollector } from '../sync/submitters/impressionCountsSubmitter';
 import { OPTIMIZED, DEBUG } from '../utils/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
@@ -60,6 +60,7 @@ 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`
         }
         // Close streaming connection
         if (this.syncManager.pushManager)

package/esm/logger/constants.js

@@ -120,6 +120,7 @@ export var ERROR_HTTP = 322;
 export var ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export var ERROR_STORAGE_INVALID = 324;
 export var ERROR_NOT_BOOLEAN = 325;
+export var ERROR_MIN_CONFIG_PARAM = 326;
 // Log prefixes (a.k.a. tags or categories)
 export var LOG_PREFIX_SETTINGS = 'settings';
 export var LOG_PREFIX_INSTANTIATION = 'Factory instantiation';