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

package/esm/sync/submitters/submitterManager.js

@@ -1,16 +1,18 @@
 import { syncTaskComposite } from '../syncTaskComposite';
-import { eventsSyncTaskFactory } from './eventsSyncTask';
-import { impressionsSyncTaskFactory } from './impressionsSyncTask';
-import { impressionCountsSyncTaskFactory } from './impressionCountsSyncTask';
+import { eventsSubmitterFactory } from './eventsSubmitter';
+import { impressionsSubmitterFactory } from './impressionsSubmitter';
+import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
+import { telemetrySubmitterFactory } from './telemetrySubmitter';
 export function submitterManagerFactory(params) {
-    var settings = params.settings, storage = params.storage, splitApi = params.splitApi;
-    var log = settings.log;
     var submitters = [
-        impressionsSyncTaskFactory(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),
-        eventsSyncTaskFactory(log, splitApi.postEventsBulk, storage.events, settings.scheduler.eventsPushRate, settings.startup.eventsFirstPushWindow)
-        // @TODO add telemetry submitter
+        impressionsSubmitterFactory(params),
+        eventsSubmitterFactory(params)
     ];
-    if (storage.impressionCounts)
-        submitters.push(impressionCountsSyncTaskFactory(log, splitApi.postTestImpressionsCount, storage.impressionCounts));
+    var impressionCountsSubmitter = impressionCountsSubmitterFactory(params);
+    if (impressionCountsSubmitter)
+        submitters.push(impressionCountsSubmitter);
+    var telemetrySubmitter = telemetrySubmitterFactory(params);
+    if (telemetrySubmitter)
+        submitters.push(telemetrySubmitter);
     return syncTaskComposite(submitters);
 }

package/esm/sync/submitters/telemetrySubmitter.js

@@ -0,0 +1,122 @@
+var _a, _b;
+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 { 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';
+/**
+ * Converts data from telemetry cache into /metrics/usage request payload.
+ */
+export 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(QUEUED),
+                iDe: telemetry.getImpressionStats(DEDUPED),
+                iDr: telemetry.getImpressionStats(DROPPED),
+                spC: splits.getSplitNames().length,
+                seC: segments.getRegisteredSegments().length,
+                skC: segments.getKeysCount(),
+                sL: telemetry.getSessionLength(),
+                eQ: telemetry.getEventStats(QUEUED),
+                eD: telemetry.getEventStats(DROPPED),
+                sE: telemetry.popStreamingEvents(),
+                t: telemetry.popTags(),
+            };
+        }
+    };
+}
+var OPERATION_MODE_MAP = (_a = {},
+    _a[STANDALONE_MODE] = STANDALONE_ENUM,
+    _a[CONSUMER_MODE] = CONSUMER_ENUM,
+    _a[CONSUMER_PARTIAL_MODE] = CONSUMER_PARTIAL_ENUM,
+    _a);
+var IMPRESSIONS_MODE_MAP = (_b = {},
+    _b[OPTIMIZED] = OPTIMIZED_ENUM,
+    _b[DEBUG] = DEBUG_ENUM,
+    _b);
+function getActiveFactories() {
+    return Object.keys(usedKeysMap).length;
+}
+function getRedundantActiveFactories() {
+    return Object.keys(usedKeysMap).reduce(function (acum, apiKey) {
+        return acum + usedKeysMap[apiKey] - 1;
+    }, 0);
+}
+/**
+ * Converts data from telemetry cache and settings into /metrics/config request payload.
+ */
+export 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 !== base.urls.sdk,
+                    e: urls.events !== base.urls.events,
+                    a: urls.auth !== base.urls.auth,
+                    st: urls.streaming !== base.urls.streaming,
+                    t: urls.telemetry !== 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; }),
+            };
+        }
+    };
+}
+/**
+ * Submitter that periodically posts telemetry data
+ */
+export function telemetrySubmitterFactory(params) {
+    var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry;
+    if (!telemetry)
+        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 = timer(now || Date.now);
+    var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
+    readiness.gate.once(SDK_READY_FROM_CACHE, function () {
+        telemetry.recordTimeUntilReadyFromCache(startTime());
+    });
+    readiness.gate.once(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 = submitterFactory(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, 'telemetry config', undefined, 0, true);
+            postMetricsConfigTask.execute();
+        }
+    });
+    return submitter;
+}

package/esm/sync/syncManagerOnline.js

@@ -2,6 +2,7 @@ import { submitterManagerFactory } from './submitters/submitterManager';
 import { PUSH_SUBSYSTEM_UP, PUSH_SUBSYSTEM_DOWN } from './streaming/constants';
 import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
+import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -15,7 +16,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
      * 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 */
@@ -33,13 +34,16 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
             else {
                 log.info(SYNC_START_POLLING);
                 pollingManager.start();
+                telemetryTracker.streamingEvent(SYNC_MODE_UPDATE, POLLING);
             }
         }
         function stopPollingAndSyncAll() {
             log.info(SYNC_STOP_POLLING);
             // if polling, stop
-            if (pollingManager.isRunning())
+            if (pollingManager.isRunning()) {
                 pollingManager.stop();
+                telemetryTracker.streamingEvent(SYNC_MODE_UPDATE, STREAMING);
+            }
             // fetch splits and segments. There is no need to catch this promise (it is always resolved)
             pollingManager.syncAll();
         }

package/esm/trackers/eventTracker.js

@@ -1,7 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { EVENTS_TRACKER_SUCCESS, ERROR_EVENTS_TRACKER } from '../logger/constants';
-import { CONSENT_DECLINED } from '../utils/constants';
+import { CONSENT_DECLINED, DROPPED, QUEUED } from '../utils/constants';
 import { isStorageSync } from './impressionObserver/utils';
 /**
  * Event tracker stores events in cache and pass them to the integrations manager if provided.
@@ -9,7 +9,7 @@ import { isStorageSync } from './impressionObserver/utils';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export function eventTrackerFactory(settings, eventsCache, integrationsManager) {
+export function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
     var log = settings.log;
     var isSync = isStorageSync(settings);
     function queueEventsCallback(eventData, tracked) {
@@ -45,6 +45,10 @@ export 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 ? QUEUED : DROPPED, 1);
                 return queueEventsCallback(eventData, tracked);
             }
         }

package/esm/trackers/impressionsTracker.js

@@ -2,7 +2,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { truncateTimeFrame } from '../utils/time';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
-import { CONSENT_DECLINED } from '../utils/constants';
+import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  *
@@ -17,7 +17,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, integratio
 // 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) {
@@ -50,6 +50,14 @@ countsCache) {
                     log.error(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(QUEUED, impressionsToStore.length);
+                    telemetryCache.recordImpressionStats(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/esm/trackers/telemetryTracker.js

@@ -0,0 +1,61 @@
+import { EXCEPTION, SDK_NOT_READY } from '../utils/labels';
+import { timer } from '../utils/timeTracker/timer';
+import { TOKEN_REFRESH, AUTH_REJECTION } from '../utils/constants';
+export function telemetryTrackerFactory(telemetryCache, now) {
+    if (telemetryCache && now) {
+        var startTime_1 = timer(now);
+        return {
+            trackEval: function (method) {
+                var evalTime = timer(now);
+                return function (label) {
+                    switch (label) {
+                        case EXCEPTION:
+                            telemetryCache.recordException(method);
+                            return; // Don't track latency on exceptions
+                        case 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 = 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 === AUTH_REJECTION) {
+                    telemetryCache.recordAuthRejections();
+                }
+                else {
+                    telemetryCache.recordStreamingEvents({
+                        e: e,
+                        d: d,
+                        t: now()
+                    });
+                    if (e === 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 () { },
+        };
+    }
+}

package/esm/utils/constants/index.js

@@ -28,3 +28,41 @@ export var STORAGE_PLUGGABLE = 'PLUGGABLE';
 export var CONSENT_GRANTED = 'GRANTED'; // The user has granted consent for tracking events and impressions
 export var CONSENT_DECLINED = 'DECLINED'; // The user has declined consent for tracking events and impressions
 export var CONSENT_UNKNOWN = 'UNKNOWN'; // The user has neither granted nor declined consent for tracking events and impressions
+// Telemetry
+export var QUEUED = 0;
+export var DROPPED = 1;
+export var DEDUPED = 2;
+export var STANDALONE_ENUM = 0;
+export var CONSUMER_ENUM = 1;
+export var CONSUMER_PARTIAL_ENUM = 2;
+export var OPTIMIZED_ENUM = 0;
+export var DEBUG_ENUM = 1;
+export var SPLITS = 'sp';
+export var IMPRESSIONS = 'im';
+export var IMPRESSIONS_COUNT = 'ic';
+export var EVENTS = 'ev';
+export var TELEMETRY = 'te';
+export var TOKEN = 'to';
+export var SEGMENT = 'se';
+export var MY_SEGMENT = 'ms';
+export var TREATMENT = 't';
+export var TREATMENTS = 'ts';
+export var TREATMENT_WITH_CONFIG = 'tc';
+export var TREATMENTS_WITH_CONFIG = 'tcs';
+export var TRACK = 'tr';
+export var CONNECTION_ESTABLISHED = 0;
+export var OCCUPANCY_PRI = 10;
+export var OCCUPANCY_SEC = 20;
+export var STREAMING_STATUS = 30;
+export var SSE_CONNECTION_ERROR = 40;
+export var TOKEN_REFRESH = 50;
+export var ABLY_ERROR = 60;
+export var SYNC_MODE_UPDATE = 70;
+export var AUTH_REJECTION = 80;
+export var STREAMING = 0;
+export var POLLING = 1;
+export var REQUESTED = 0;
+export var NON_REQUESTED = 1;
+export var DISABLED = 0;
+export var ENABLED = 1;
+export var PAUSED = 2;

package/esm/utils/inputValidation/apiKey.js

@@ -18,7 +18,8 @@ export function validateApiKey(log, maybeApiKey) {
     }
     return apiKey;
 }
-var usedKeysMap = {};
+// Exported for telemetry
+export var usedKeysMap = {};
 /** validates the given api key and also warns if it is in use */
 export function validateAndTrackApiKey(log, maybeApiKey) {
     var apiKey = validateApiKey(log, maybeApiKey);

package/esm/utils/settingsValidation/index.js

@@ -1,11 +1,13 @@
 import { merge } from '../lang';
 import { mode } from './mode';
 import { validateSplitFilters } from './splitFilters';
-import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE } from '../constants';
+import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
 import { validateKey } from '../inputValidation/key';
 import { validateTrafficType } from '../inputValidation/trafficType';
-var base = {
+import { ERROR_MIN_CONFIG_PARAM } from '../../logger/constants';
+// Exported for telemetry
+export var base = {
     // Define which kind of object you want to retrieve from SplitFactory
     mode: STANDALONE_MODE,
     core: {
@@ -25,10 +27,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
@@ -49,6 +51,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,
@@ -89,14 +93,36 @@ export 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 = 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(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 !== base.scheduler.impressionsRefreshRate) {
+        // Validate impressionsRefreshRate defined by user
+        scheduler.impressionsRefreshRate = validateMinValue('impressionsRefreshRate', scheduler.impressionsRefreshRate, withDefaults.sync.impressionsMode === 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 === 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);
@@ -149,8 +175,6 @@ export function settingsValidation(config, validationParams) {
     var splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
     withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
     withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
-    // ensure a valid impressionsMode
-    withDefaults.sync.impressionsMode = validImpressionsMode(log, withDefaults.sync.impressionsMode);
     // ensure a valid user consent value
     // @ts-ignore, modify readonly prop
     withDefaults.userConsent = consent(withDefaults);

package/esm/utils/settingsValidation/url.js

@@ -1,3 +1,4 @@
+var telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 var eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 var authEndpointMatcher = /^\/v2\/auth/;
 var streamingEndpointMatcher = /^\/(sse|event-stream)/;
@@ -10,6 +11,9 @@ var streamingEndpointMatcher = /^\/(sse|event-stream)/;
  * @return complete url
  */
 export function url(settings, target) {
+    if (telemetryEndpointMatcher.test(target)) {
+        return "" + settings.urls.telemetry + target;
+    }
     if (eventsEndpointMatcher.test(target)) {
         return "" + settings.urls.events + target;
     }

package/esm/utils/timeTracker/index.js

@@ -122,6 +122,7 @@ export var 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 = uniqueId();
         var taskCollector = getCollectorForTask(task, collectors);
         var result;

package/esm/utils/timeTracker/timer.js

@@ -1,6 +1,6 @@
 export 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);
     };
 }

package/package.json

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

package/src/consent/sdkUserConsent.ts

@@ -23,7 +23,7 @@ export function createUserConsentAPI(params: ISdkFactoryContext) {
     setStatus(consent: unknown) {
       // validate input param
       if (!isBoolean(consent)) {
-        log.warn(ERROR_NOT_BOOLEAN, ['setUserConsent']);
+        log.warn(ERROR_NOT_BOOLEAN, ['UserConsent.setStatus']);
         return false;
       }
 

package/src/listeners/browser.ts

@@ -2,8 +2,8 @@
 // @TODO eventually migrate to JS-Browser-SDK package.
 import { ISignalListener } from './types';
 import { IRecorderCacheProducerSync, IStorageSync } from '../storages/types';
-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 { IResponse, ISplitApi } from '../services/types';
 import { ImpressionDTO, ISettings } from '../types';
 import { ImpressionsPayload } from '../sync/submitters/types';
@@ -77,6 +77,7 @@ 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`
     }
 
     // Close streaming connection

package/src/logger/constants.ts

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

package/src/logger/messages/error.ts

@@ -32,5 +32,6 @@ export const codesError: [number, string][] = [
   // initialization / settings validation
   [c.ERROR_INVALID_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "%s" config param. It should be one of the following values: %s. Defaulting to "%s".'],
   [c.ERROR_LOCALHOST_MODULE_REQUIRED, c.LOG_PREFIX_SETTINGS + ': an invalid value was received for "sync.localhostMode" config. A valid entity should be provided for localhost mode.'],
-  [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS+': The provided storage is invalid.%s Fallbacking into default MEMORY storage'],
+  [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS+': the provided storage is invalid.%s Falling back into default MEMORY storage'],
+  [c.ERROR_MIN_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': the provided "%s" config param is lower than allowed. Setting to the minimum value %s seconds'],
 ];

package/src/logger/messages/info.ts

@@ -14,8 +14,8 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.NEW_FACTORY, 'New Split SDK instance created.'],
   [c.EVENTS_TRACKER_SUCCESS, c.LOG_PREFIX_EVENTS_TRACKER + 'Successfully queued %s'],
   [c.IMPRESSIONS_TRACKER_SUCCESS, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Successfully stored %s impression(s).'],
-  [c.USER_CONSENT_UPDATED, 'setUserConsent: consent status changed from %s to %s.'],
-  [c.USER_CONSENT_NOT_UPDATED, 'setUserConsent: call had no effect because it was the current consent status (%s).'],
+  [c.USER_CONSENT_UPDATED, 'UserConsent: consent status changed from %s to %s.'],
+  [c.USER_CONSENT_NOT_UPDATED, 'UserConsent: call had no effect because it was the current consent status (%s).'],
   [c.USER_CONSENT_INITIAL, 'Starting the SDK with %s user consent. No data will be sent.'],
 
   // synchronizer
@@ -24,7 +24,7 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
   [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of splits #%s. Reason: %s'],
   [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
-  [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s %s.'],
+  [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
   [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
   [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],
   [c.STREAMING_CONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Connecting streaming.'],

package/src/logger/messages/warn.ts

@@ -11,8 +11,8 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.STREAMING_PARSING_ERROR_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE error notification: %s'],
   [c.STREAMING_PARSING_MESSAGE_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE message notification: %s'],
   [c.STREAMING_FALLBACK, c.LOG_PREFIX_SYNC_STREAMING + 'Falling back to polling mode. Reason: %s'],
-  [c.SUBMITTERS_PUSH_FAILS, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Droping %s %s after retry. Reason: %s.'],
-  [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s %s, keeping data to retry on next iteration. Reason: %s.'],
+  [c.SUBMITTERS_PUSH_FAILS, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Droping %s after retry. Reason: %s.'],
+  [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s, keeping data to retry on next iteration. Reason: %s.'],
   // client status
   [c.CLIENT_NOT_READY, '%s: the SDK is not ready, results may be incorrect. Make sure to wait for SDK readiness before using this method.'],
   [c.CLIENT_NO_LISTENER, 'No listeners for SDK Readiness detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet ready.'],