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

package/CHANGES.txt

@@ -1,3 +1,8 @@
+1.4.0 (May 24, 2022)
+ - Added `scheduler.telemetryRefreshRate` property to SDK configuration, and deprecated `scheduler.metricsRefreshRate` property.
+ - Updated SDK telemetry storage, metrics and updater to be more effective and send less often.
+ - Bugfixing - Updated default values for `scheduler.impressionsRefreshRate` config parameter: 300s for OPTIMIZED impression mode and 60s for DEBUG impression mode.
+
 1.3.1 (April 19, 2022)
  - Bugfixing - Added peer dependencies to avoid issues when requiring some third-party dependencies used by modules of the package (Related to issue https://github.com/splitio/javascript-client/issues/662).
  - Bugfixing - Updated `ready` method to rejects the promise with an Error object instead of a string value (Related to issue https://github.com/splitio/javascript-client/issues/654).

package/cjs/sync/submitters/telemetrySubmitter.js

@@ -82,14 +82,16 @@ function telemetryCacheConfigAdapter(telemetry, settings) {
         clear: function () { },
         state: function () {
             var urls = settings.urls, scheduler = settings.scheduler;
+            var isClientSide = settings.core.key !== undefined;
             return (0, objectAssign_1.objectAssign)(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
                 rR: {
-                    sp: scheduler.featuresRefreshRate,
-                    se: scheduler.segmentsRefreshRate,
-                    im: scheduler.impressionsRefreshRate,
-                    ev: scheduler.eventsPushRate,
-                    te: scheduler.telemetryRefreshRate,
+                    sp: scheduler.featuresRefreshRate / 1000,
+                    se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
+                    ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+                    im: scheduler.impressionsRefreshRate / 1000,
+                    ev: scheduler.eventsPushRate / 1000,
+                    te: scheduler.telemetryRefreshRate / 1000,
                 },
                 uO: {
                     s: urls.sdk !== settingsValidation_1.base.urls.sdk,
@@ -118,11 +120,11 @@ exports.telemetryCacheConfigAdapter = telemetryCacheConfigAdapter;
  * Submitter that periodically posts telemetry data
  */
 function telemetrySubmitterFactory(params) {
-    var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry;
-    if (!telemetry)
+    var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry, now = params.platform.now;
+    if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, now = params.platform.now, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
-    var startTime = (0, timer_1.timer)(now || Date.now);
+    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
+    var startTime = (0, timer_1.timer)(now);
     var submitter = (0, submitter_1.firstPushWindowDecorator)((0, submitter_1.submitterFactory)(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(constants_2.SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());

package/cjs/trackers/telemetryTracker.js

@@ -29,7 +29,7 @@ function telemetryTrackerFactory(telemetryCache, now) {
                     if (error && error.statusCode)
                         telemetryCache.recordHttpError(operation, error.statusCode);
                     else
-                        telemetryCache.recordSuccessfulSync(operation, now());
+                        telemetryCache.recordSuccessfulSync(operation, Date.now());
                 };
             },
             sessionLength: function () {
@@ -44,7 +44,7 @@ function telemetryTrackerFactory(telemetryCache, now) {
                     telemetryCache.recordStreamingEvents({
                         e: e,
                         d: d,
-                        t: now()
+                        t: Date.now()
                     });
                     if (e === constants_1.TOKEN_REFRESH)
                         telemetryCache.recordTokenRefreshes();

package/cjs/utils/settingsValidation/index.js

@@ -112,16 +112,9 @@ function settingsValidation(config, validationParams) {
     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;
-    }
+    // Default impressionsRefreshRate for DEBUG mode is 60 secs
+    if ((0, lang_1.get)(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === constants_1.DEBUG)
+        scheduler.impressionsRefreshRate = 60;
     scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
     // Log deprecation for old telemetry param
     if (scheduler.metricsRefreshRate)

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

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

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

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.now = void 0;
-// @TODO migrate to Node SDK package eventually
 function now() {
     // eslint-disable-next-line no-undef
     var time = process.hrtime();
-    return time[0] * 1e3 + time[1] * 1e-6; // convert it to milis
+    return time[0] * 1e3 + time[1] * 1e-6; // convert it to millis
 }
 exports.now = now;

package/esm/sync/submitters/telemetrySubmitter.js

@@ -77,14 +77,16 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
         clear: function () { },
         state: function () {
             var urls = settings.urls, scheduler = settings.scheduler;
+            var isClientSide = settings.core.key !== undefined;
             return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
                 rR: {
-                    sp: scheduler.featuresRefreshRate,
-                    se: scheduler.segmentsRefreshRate,
-                    im: scheduler.impressionsRefreshRate,
-                    ev: scheduler.eventsPushRate,
-                    te: scheduler.telemetryRefreshRate,
+                    sp: scheduler.featuresRefreshRate / 1000,
+                    se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
+                    ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+                    im: scheduler.impressionsRefreshRate / 1000,
+                    ev: scheduler.eventsPushRate / 1000,
+                    te: scheduler.telemetryRefreshRate / 1000,
                 },
                 uO: {
                     s: urls.sdk !== base.urls.sdk,
@@ -112,11 +114,11 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
  * Submitter that periodically posts telemetry data
  */
 export function telemetrySubmitterFactory(params) {
-    var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry;
-    if (!telemetry)
+    var _a = params.storage, splits = _a.splits, segments = _a.segments, telemetry = _a.telemetry, now = params.platform.now;
+    if (!telemetry || !now)
         return; // No submitter created if telemetry cache is not defined
-    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, now = params.platform.now, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
-    var startTime = timer(now || Date.now);
+    var settings = params.settings, _b = params.settings, log = _b.log, telemetryRefreshRate = _b.scheduler.telemetryRefreshRate, splitApi = params.splitApi, readiness = params.readiness, sdkReadinessManager = params.sdkReadinessManager;
+    var startTime = timer(now);
     var submitter = firstPushWindowDecorator(submitterFactory(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true), telemetryRefreshRate);
     readiness.gate.once(SDK_READY_FROM_CACHE, function () {
         telemetry.recordTimeUntilReadyFromCache(startTime());

package/esm/trackers/telemetryTracker.js

@@ -26,7 +26,7 @@ export function telemetryTrackerFactory(telemetryCache, now) {
                     if (error && error.statusCode)
                         telemetryCache.recordHttpError(operation, error.statusCode);
                     else
-                        telemetryCache.recordSuccessfulSync(operation, now());
+                        telemetryCache.recordSuccessfulSync(operation, Date.now());
                 };
             },
             sessionLength: function () {
@@ -41,7 +41,7 @@ export function telemetryTrackerFactory(telemetryCache, now) {
                     telemetryCache.recordStreamingEvents({
                         e: e,
                         d: d,
-                        t: now()
+                        t: Date.now()
                     });
                     if (e === TOKEN_REFRESH)
                         telemetryCache.recordTokenRefreshes();

package/esm/utils/settingsValidation/index.js

@@ -1,4 +1,4 @@
-import { merge } from '../lang';
+import { merge, get } from '../lang';
 import { mode } from './mode';
 import { validateSplitFilters } from './splitFilters';
 import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG } from '../constants';
@@ -109,16 +109,9 @@ export function settingsValidation(config, validationParams) {
     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;
-    }
+    // Default impressionsRefreshRate for DEBUG mode is 60 secs
+    if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG)
+        scheduler.impressionsRefreshRate = 60;
     scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
     // Log deprecation for old telemetry param
     if (scheduler.metricsRefreshRate)

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

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

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

@@ -1,6 +1,5 @@
-// @TODO migrate to Node SDK package eventually
 export function now() {
     // eslint-disable-next-line no-undef
     var time = process.hrtime();
-    return time[0] * 1e3 + time[1] * 1e-6; // convert it to milis
+    return time[0] * 1e3 + time[1] * 1e-6; // convert it to millis
 }

package/package.json

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

package/src/sdkFactory/types.ts

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

package/src/sync/submitters/telemetrySubmitter.ts

@@ -59,7 +59,7 @@ const USER_CONSENT_MAP = {
   [CONSENT_UNKNOWN]: 1,
   [CONSENT_GRANTED]: 2,
   [CONSENT_DECLINED]: 3
-} as Record<ConsentStatus, (0 | 1 | 2 | 3)>;
+} as Record<ConsentStatus, number>;
 
 function getActiveFactories() {
   return Object.keys(usedKeysMap).length;
@@ -90,15 +90,17 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
 
     state(): TelemetryConfigStatsPayload {
       const { urls, scheduler } = settings;
+      const isClientSide = settings.core.key !== undefined;
 
       return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
         sE: settings.streamingEnabled,
         rR: {
-          sp: scheduler.featuresRefreshRate,
-          se: scheduler.segmentsRefreshRate,
-          im: scheduler.impressionsRefreshRate,
-          ev: scheduler.eventsPushRate,
-          te: scheduler.telemetryRefreshRate,
+          sp: scheduler.featuresRefreshRate / 1000,
+          se: isClientSide ? undefined : scheduler.segmentsRefreshRate / 1000,
+          ms: isClientSide ? scheduler.segmentsRefreshRate / 1000 : undefined,
+          im: scheduler.impressionsRefreshRate / 1000,
+          ev: scheduler.eventsPushRate / 1000,
+          te: scheduler.telemetryRefreshRate / 1000,
         }, // refreshRates
         uO: {
           s: urls.sdk !== base.urls.sdk,
@@ -127,11 +129,11 @@ export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, sett
  * Submitter that periodically posts telemetry data
  */
 export function telemetrySubmitterFactory(params: ISdkFactoryContextSync) {
-  const { storage: { splits, segments, telemetry } } = params;
-  if (!telemetry) return; // No submitter created if telemetry cache is not defined
+  const { storage: { splits, segments, telemetry }, platform: { now } } = params;
+  if (!telemetry || !now) return; // No submitter created if telemetry cache is not defined
 
-  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, platform: { now }, readiness, sdkReadinessManager } = params;
-  const startTime = timer(now || Date.now);
+  const { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, readiness, sdkReadinessManager } = params;
+  const startTime = timer(now);
 
   const submitter = firstPushWindowDecorator(
     submitterFactory(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true),

package/src/sync/submitters/types.ts

@@ -151,7 +151,8 @@ export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
 
 export type RefreshRates = {
   sp: number, // splits
-  se: number, // mySegments
+  se?: number, // segments
+  ms?: number, // mySegments
   im: number, // impressions
   ev: number, // events
   te: number, // telemetry

package/src/trackers/telemetryTracker.ts

@@ -33,7 +33,7 @@ export function telemetryTrackerFactory(
         return (error) => {
           (telemetryCache as ITelemetryCacheSync).recordHttpLatency(operation, httpTime());
           if (error && error.statusCode) (telemetryCache as ITelemetryCacheSync).recordHttpError(operation, error.statusCode);
-          else (telemetryCache as ITelemetryCacheSync).recordSuccessfulSync(operation, now());
+          else (telemetryCache as ITelemetryCacheSync).recordSuccessfulSync(operation, Date.now());
         };
       },
       sessionLength() { // @ts-ignore ITelemetryCacheAsync doesn't implement the method
@@ -44,7 +44,7 @@ export function telemetryTrackerFactory(
           (telemetryCache as ITelemetryCacheSync).recordAuthRejections();
         } else {
           (telemetryCache as ITelemetryCacheSync).recordStreamingEvents({
-            e, d, t: now()
+            e, d, t: Date.now()
           });
           if (e === TOKEN_REFRESH) (telemetryCache as ITelemetryCacheSync).recordTokenRefreshes();
         }

package/src/utils/lang/index.ts

@@ -71,7 +71,7 @@ export function forOwn<T>(obj: { [key: string]: T }, iteratee: (value: T, key: s
  * Safely retrieve the specified prop from obj. If we can't retrieve
  * that property value, we return the default value.
  */
-export function get(obj: any, prop: any, val: any): any {
+export function get(obj: any, prop: any, val?: any): any {
   let res = val;
 
   try { // No risks nor lots of checks.

package/src/utils/settingsValidation/index.ts

@@ -1,4 +1,4 @@
-import { merge } from '../lang';
+import { merge, get } from '../lang';
 import { mode } from './mode';
 import { validateSplitFilters } from './splitFilters';
 import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG } from '../constants';
@@ -131,15 +131,8 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   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;
-  }
+  // Default impressionsRefreshRate for DEBUG mode is 60 secs
+  if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG) scheduler.impressionsRefreshRate = 60;
   scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
 
   // Log deprecation for old telemetry param

package/src/utils/timeTracker/now/browser.ts

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

package/src/utils/timeTracker/now/node.ts

@@ -1,7 +1,6 @@
-// @TODO migrate to Node SDK package eventually
 export function now() {
   // eslint-disable-next-line no-undef
   let time = process.hrtime();
 
-  return time[0] * 1e3 + time[1] * 1e-6; // convert it to milis
+  return time[0] * 1e3 + time[1] * 1e-6; // convert it to millis
 }

package/types/sdkFactory/types.d.ts

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

package/types/sync/submitters/types.d.ts

@@ -134,7 +134,8 @@ export declare type DEBUG_ENUM = 1;
 export declare type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
 export declare type RefreshRates = {
     sp: number;
-    se: number;
+    se?: number;
+    ms?: number;
     im: number;
     ev: number;
     te: number;

package/types/utils/lang/index.d.ts

@@ -28,7 +28,7 @@ export declare function forOwn<T>(obj: {
  * Safely retrieve the specified prop from obj. If we can't retrieve
  * that property value, we return the default value.
  */
-export declare function get(obj: any, prop: any, val: any): any;
+export declare function get(obj: any, prop: any, val?: any): any;
 /**
  * Parses an array into a map of different arrays, grouping by the specified prop value.
  */

package/types/utils/timeTracker/index.d.ts

@@ -1,70 +1 @@
-import { ILogger } from '../../logger/types';
-import { IResponse } from '../../services/types';
-interface MetricsCollector {
-    countException(): void;
-    count(status: number): void;
-    latency(ms: number): void;
-    ready(ms: number): void;
-    getTreatment(ms: number): void;
-    getTreatments(ms: number): void;
-    getTreatmentWithConfig(ms: number): void;
-    getTreatmentsWithConfig(ms: number): void;
-    [method: string]: (ms: number) => void;
-}
-export declare const TrackerAPI: {
-    /**
-     * "Private" method, used to attach count/countException and stop callbacks to a promise.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {Promise} promise - The promise we want to attach the callbacks.
-     * @param {string} task - The name of the task.
-     * @param {number | string} modifier - (optional) The modifier for the task, if any.
-     */
-    __attachToPromise(log: ILogger, promise: Promise<IResponse>, task: string, collector: false | MetricsCollector, modifier?: string | number | undefined): Promise<IResponse>;
-    /**
-     * Starts tracking the time for a given task. All tasks tracked are considered "unique" because
-     * there may be multiple SDK instances tracking a "generic" task, making any task non-generic.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {string} task - The task we are starting.
-     * @param {Object} collectors - The collectors map.
-     * @param {Promise} promise - (optional) The promise we are tracking.
-     * @return {Function | Promise} The stop function for this specific task or the promise received with the callbacks registered.
-     */
-    start(log: ILogger, task: string, collectors?: Record<string, MetricsCollector> | undefined, promise?: Promise<IResponse> | undefined, now?: () => number): Promise<IResponse> | (() => number);
-    /**
-     * Setup the collector for a task that reports metrics.
-     *
-     * @param {string} task - The task name
-     * @param {number | string} taskUniqueId - The unique identifier for this task
-     * @param {Object} collectors - The collectors map.
-     */
-    setCollectorForTask(task: string, taskUniqueId: number | string, collectors: Record<string, MetricsCollector>): void;
-    /**
-     * Stops the tracking of a given task.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {string} task - The task we are starting.
-     * @param {number | string} modifier - (optional) The modifier for that specific task.
-     */
-    stop(log: ILogger, task: string, modifier?: string | number | undefined): number | undefined;
-    /**
-     * The constants shortcut for the task names.
-     */
-    TaskNames: {
-        SDK_READY: string;
-        SDK_GET_TREATMENT: string;
-        SDK_GET_TREATMENTS: string;
-        SDK_GET_TREATMENT_WITH_CONFIG: string;
-        SDK_GET_TREATMENTS_WITH_CONFIG: string;
-        SPLITS_READY: string;
-        SEGMENTS_READY: string;
-        METRICS_PUSH: string;
-        IMPRESSIONS_PUSH: string;
-        EVENTS_PUSH: string;
-        MY_SEGMENTS_FETCH: string;
-        SEGMENTS_FETCH: string;
-        SPLITS_FETCH: string;
-    };
-};
-export {};
+export declare function timeTracker(now: () => number): () => () => number;

package/cjs/utils/timeTracker/index.js

@@ -1,197 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrackerAPI = void 0;
-var lang_1 = require("../lang");
-var timer_1 = require("./timer");
-var thenable_1 = require("../promise/thenable");
-// Map we will use for storing timers data
-var timers = {};
-// Tasks constants
-var CONSTANTS = {
-    SDK_READY: 'Getting ready - Split SDK',
-    SDK_GET_TREATMENT: 'SDK - Get Treatment',
-    SDK_GET_TREATMENTS: 'SDK - Get Treatments',
-    SDK_GET_TREATMENT_WITH_CONFIG: 'SDK - Get Treatment with config',
-    SDK_GET_TREATMENTS_WITH_CONFIG: 'SDK - Get Treatments with config',
-    SPLITS_READY: 'Getting ready - Splits',
-    SEGMENTS_READY: 'Getting ready - Segments',
-    METRICS_PUSH: 'Pushing - Metrics',
-    IMPRESSIONS_PUSH: 'Pushing - Impressions',
-    EVENTS_PUSH: 'Pushing - Events',
-    MY_SEGMENTS_FETCH: 'Fetching - My Segments',
-    SEGMENTS_FETCH: 'Fetching - Segments',
-    SPLITS_FETCH: 'Fetching - Splits'
-};
-// Tasks callbacks, if any
-var CALLBACKS = (_a = {},
-    _a[CONSTANTS.SDK_READY] = {
-        collector: 'client',
-        method: 'ready'
-    },
-    _a[CONSTANTS.SDK_GET_TREATMENT] = {
-        collector: 'client',
-        method: 'getTreatment'
-    },
-    _a[CONSTANTS.SDK_GET_TREATMENTS] = {
-        collector: 'client',
-        method: 'getTreatments'
-    },
-    _a[CONSTANTS.SDK_GET_TREATMENT_WITH_CONFIG] = {
-        collector: 'client',
-        method: 'getTreatmentWithConfig'
-    },
-    _a[CONSTANTS.SDK_GET_TREATMENTS_WITH_CONFIG] = {
-        collector: 'client',
-        method: 'getTreatmentsWithConfig'
-    },
-    _a[CONSTANTS.MY_SEGMENTS_FETCH] = {
-        collector: 'mySegments',
-        method: 'latency'
-    },
-    _a[CONSTANTS.SEGMENTS_FETCH] = {
-        collector: 'segmentChanges',
-        method: 'latency'
-    },
-    _a[CONSTANTS.SPLITS_FETCH] = {
-        collector: 'splitChanges',
-        method: 'latency'
-    },
-    _a);
-/**
- * Generates the timer keys using the task name and a modifier, if any.
- * @param {string} task - The task name
- * @param {number | string} modifier - (optional) The modifier, if any.
- * @return {string} The generated timer key
- */
-function generateTimerKey(task, modifier) { return modifier ? task + modifier : task; }
-/**
- * Given the collectors map, it returns the specific collector for a given task.
- *
- * @param {string} task - The task name
- * @param {Object} collectors - The collectors map
- */
-function getCollectorForTask(task, collectors) {
-    var callbackData = CALLBACKS[task];
-    if (callbackData && collectors)
-        return collectors[callbackData.collector];
-    return false;
-}
-/**
- * Given a collector and a task, returns the callback function that should be called when we stop the timer.
- *
- * @param {string} task - The task name
- * @param {Object} collector - The collector object for the task
- */
-function getCallbackForTask(task, collector) {
-    var callbackData = CALLBACKS[task];
-    if (callbackData && collector)
-        return collector[callbackData.method];
-    return false;
-}
-// Our "time tracker" API
-exports.TrackerAPI = {
-    /**
-     * "Private" method, used to attach count/countException and stop callbacks to a promise.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {Promise} promise - The promise we want to attach the callbacks.
-     * @param {string} task - The name of the task.
-     * @param {number | string} modifier - (optional) The modifier for the task, if any.
-     */
-    __attachToPromise: function (log, promise, task, collector, modifier) {
-        var _this = this;
-        return promise.then(function (resp) {
-            _this.stop(log, task, modifier);
-            if (collector && collector.count)
-                collector.count(resp.status);
-            return resp;
-        })
-            .catch(function (err) {
-            _this.stop(log, task, modifier);
-            if (collector && collector.countException)
-                collector.countException();
-            throw err;
-        });
-    },
-    /**
-     * Starts tracking the time for a given task. All tasks tracked are considered "unique" because
-     * there may be multiple SDK instances tracking a "generic" task, making any task non-generic.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {string} task - The task we are starting.
-     * @param {Object} collectors - The collectors map.
-     * @param {Promise} promise - (optional) The promise we are tracking.
-     * @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;
-        // If we are registering a promise with this task, we should count the status and the exceptions as well
-        // as stopping the task when the promise resolves. Then return the promise
-        if ((0, thenable_1.thenable)(promise)) {
-            result = this.__attachToPromise(log, promise, task, taskCollector, taskUniqueId);
-        }
-        else {
-            // If not, we return the stop function, as it will be stopped manually.
-            result = this.stop.bind(this, log, task, taskUniqueId);
-            if (CALLBACKS[task] && !taskCollector) {
-                // and provide a way for a defered setup of the collector, if needed.
-                // @ts-expect-error
-                result.setCollectorForTask = this.setCollectorForTask.bind(this, task, taskUniqueId);
-            }
-        }
-        // We start the timer, with an uniqueId attached to it's name, and save tracking info for this task.
-        var trackingKey = generateTimerKey(task, taskUniqueId);
-        var cb = getCallbackForTask(task, taskCollector);
-        timers[trackingKey] = {
-            cb: cb,
-            timer: (0, timer_1.timer)(now)
-        };
-        return result;
-    },
-    /**
-     * Setup the collector for a task that reports metrics.
-     *
-     * @param {string} task - The task name
-     * @param {number | string} taskUniqueId - The unique identifier for this task
-     * @param {Object} collectors - The collectors map.
-     */
-    setCollectorForTask: function (task, taskUniqueId, collectors) {
-        var taskCollector = getCollectorForTask(task, collectors);
-        if (taskCollector) {
-            var trackingKey = generateTimerKey(task, taskUniqueId);
-            timers[trackingKey].cb = getCallbackForTask(task, taskCollector);
-        }
-    },
-    /**
-     * Stops the tracking of a given task.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {string} task - The task we are starting.
-     * @param {number | string} modifier - (optional) The modifier for that specific task.
-     */
-    stop: function (log, task, modifier) {
-        var timerName = generateTimerKey(task, modifier);
-        var timerData = timers[timerName];
-        if (timerData) {
-            // Stop the timer and round result for readability.
-            var et = timerData.timer();
-            log.debug("[TIME TRACKER]: [" + task + "] took " + et + "ms to finish.");
-            // Check if we have a tracker callback.
-            if (timerData.cb) {
-                // If we have a callback, we call it with the elapsed time of the task and then delete the reference.
-                timerData.cb(et);
-            }
-            // Remove the task tracking reference.
-            delete timers[timerName];
-            return et;
-        }
-    },
-    /**
-     * The constants shortcut for the task names.
-     */
-    TaskNames: CONSTANTS
-};

package/esm/utils/timeTracker/index.js

@@ -1,194 +0,0 @@
-var _a;
-import { uniqueId } from '../lang';
-import { timer } from './timer';
-import { thenable } from '../promise/thenable';
-// Map we will use for storing timers data
-var timers = {};
-// Tasks constants
-var CONSTANTS = {
-    SDK_READY: 'Getting ready - Split SDK',
-    SDK_GET_TREATMENT: 'SDK - Get Treatment',
-    SDK_GET_TREATMENTS: 'SDK - Get Treatments',
-    SDK_GET_TREATMENT_WITH_CONFIG: 'SDK - Get Treatment with config',
-    SDK_GET_TREATMENTS_WITH_CONFIG: 'SDK - Get Treatments with config',
-    SPLITS_READY: 'Getting ready - Splits',
-    SEGMENTS_READY: 'Getting ready - Segments',
-    METRICS_PUSH: 'Pushing - Metrics',
-    IMPRESSIONS_PUSH: 'Pushing - Impressions',
-    EVENTS_PUSH: 'Pushing - Events',
-    MY_SEGMENTS_FETCH: 'Fetching - My Segments',
-    SEGMENTS_FETCH: 'Fetching - Segments',
-    SPLITS_FETCH: 'Fetching - Splits'
-};
-// Tasks callbacks, if any
-var CALLBACKS = (_a = {},
-    _a[CONSTANTS.SDK_READY] = {
-        collector: 'client',
-        method: 'ready'
-    },
-    _a[CONSTANTS.SDK_GET_TREATMENT] = {
-        collector: 'client',
-        method: 'getTreatment'
-    },
-    _a[CONSTANTS.SDK_GET_TREATMENTS] = {
-        collector: 'client',
-        method: 'getTreatments'
-    },
-    _a[CONSTANTS.SDK_GET_TREATMENT_WITH_CONFIG] = {
-        collector: 'client',
-        method: 'getTreatmentWithConfig'
-    },
-    _a[CONSTANTS.SDK_GET_TREATMENTS_WITH_CONFIG] = {
-        collector: 'client',
-        method: 'getTreatmentsWithConfig'
-    },
-    _a[CONSTANTS.MY_SEGMENTS_FETCH] = {
-        collector: 'mySegments',
-        method: 'latency'
-    },
-    _a[CONSTANTS.SEGMENTS_FETCH] = {
-        collector: 'segmentChanges',
-        method: 'latency'
-    },
-    _a[CONSTANTS.SPLITS_FETCH] = {
-        collector: 'splitChanges',
-        method: 'latency'
-    },
-    _a);
-/**
- * Generates the timer keys using the task name and a modifier, if any.
- * @param {string} task - The task name
- * @param {number | string} modifier - (optional) The modifier, if any.
- * @return {string} The generated timer key
- */
-function generateTimerKey(task, modifier) { return modifier ? task + modifier : task; }
-/**
- * Given the collectors map, it returns the specific collector for a given task.
- *
- * @param {string} task - The task name
- * @param {Object} collectors - The collectors map
- */
-function getCollectorForTask(task, collectors) {
-    var callbackData = CALLBACKS[task];
-    if (callbackData && collectors)
-        return collectors[callbackData.collector];
-    return false;
-}
-/**
- * Given a collector and a task, returns the callback function that should be called when we stop the timer.
- *
- * @param {string} task - The task name
- * @param {Object} collector - The collector object for the task
- */
-function getCallbackForTask(task, collector) {
-    var callbackData = CALLBACKS[task];
-    if (callbackData && collector)
-        return collector[callbackData.method];
-    return false;
-}
-// Our "time tracker" API
-export var TrackerAPI = {
-    /**
-     * "Private" method, used to attach count/countException and stop callbacks to a promise.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {Promise} promise - The promise we want to attach the callbacks.
-     * @param {string} task - The name of the task.
-     * @param {number | string} modifier - (optional) The modifier for the task, if any.
-     */
-    __attachToPromise: function (log, promise, task, collector, modifier) {
-        var _this = this;
-        return promise.then(function (resp) {
-            _this.stop(log, task, modifier);
-            if (collector && collector.count)
-                collector.count(resp.status);
-            return resp;
-        })
-            .catch(function (err) {
-            _this.stop(log, task, modifier);
-            if (collector && collector.countException)
-                collector.countException();
-            throw err;
-        });
-    },
-    /**
-     * Starts tracking the time for a given task. All tasks tracked are considered "unique" because
-     * there may be multiple SDK instances tracking a "generic" task, making any task non-generic.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {string} task - The task we are starting.
-     * @param {Object} collectors - The collectors map.
-     * @param {Promise} promise - (optional) The promise we are tracking.
-     * @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;
-        // If we are registering a promise with this task, we should count the status and the exceptions as well
-        // as stopping the task when the promise resolves. Then return the promise
-        if (thenable(promise)) {
-            result = this.__attachToPromise(log, promise, task, taskCollector, taskUniqueId);
-        }
-        else {
-            // If not, we return the stop function, as it will be stopped manually.
-            result = this.stop.bind(this, log, task, taskUniqueId);
-            if (CALLBACKS[task] && !taskCollector) {
-                // and provide a way for a defered setup of the collector, if needed.
-                // @ts-expect-error
-                result.setCollectorForTask = this.setCollectorForTask.bind(this, task, taskUniqueId);
-            }
-        }
-        // We start the timer, with an uniqueId attached to it's name, and save tracking info for this task.
-        var trackingKey = generateTimerKey(task, taskUniqueId);
-        var cb = getCallbackForTask(task, taskCollector);
-        timers[trackingKey] = {
-            cb: cb,
-            timer: timer(now)
-        };
-        return result;
-    },
-    /**
-     * Setup the collector for a task that reports metrics.
-     *
-     * @param {string} task - The task name
-     * @param {number | string} taskUniqueId - The unique identifier for this task
-     * @param {Object} collectors - The collectors map.
-     */
-    setCollectorForTask: function (task, taskUniqueId, collectors) {
-        var taskCollector = getCollectorForTask(task, collectors);
-        if (taskCollector) {
-            var trackingKey = generateTimerKey(task, taskUniqueId);
-            timers[trackingKey].cb = getCallbackForTask(task, taskCollector);
-        }
-    },
-    /**
-     * Stops the tracking of a given task.
-     *
-     * @param {ILogger} log - Logger.
-     * @param {string} task - The task we are starting.
-     * @param {number | string} modifier - (optional) The modifier for that specific task.
-     */
-    stop: function (log, task, modifier) {
-        var timerName = generateTimerKey(task, modifier);
-        var timerData = timers[timerName];
-        if (timerData) {
-            // Stop the timer and round result for readability.
-            var et = timerData.timer();
-            log.debug("[TIME TRACKER]: [" + task + "] took " + et + "ms to finish.");
-            // Check if we have a tracker callback.
-            if (timerData.cb) {
-                // If we have a callback, we call it with the elapsed time of the task and then delete the reference.
-                timerData.cb(et);
-            }
-            // Remove the task tracking reference.
-            delete timers[timerName];
-            return et;
-        }
-    },
-    /**
-     * The constants shortcut for the task names.
-     */
-    TaskNames: CONSTANTS
-};

package/src/utils/timeTracker/index.ts

@@ -1,226 +0,0 @@
-import { uniqueId } from '../lang';
-import { timer } from './timer';
-import { thenable } from '../promise/thenable';
-import { ILogger } from '../../logger/types';
-import { IResponse } from '../../services/types';
-
-// Based on ProducerMetricsCollector and ClientCollector classes
-interface MetricsCollector {
-  // ProducerMetricsCollector API
-  countException(): void,
-  count(status: number): void,
-  latency(ms: number): void,
-
-  // ClientCollector API
-  ready(ms: number): void,
-  getTreatment(ms: number): void,
-  getTreatments(ms: number): void,
-  getTreatmentWithConfig(ms: number): void,
-  getTreatmentsWithConfig(ms: number): void,
-
-  [method: string]: (ms: number) => void,
-}
-
-// Map we will use for storing timers data
-const timers: Record<string, {
-  cb: false | ((et: number) => void),
-  timer: () => number
-}> = {};
-
-// Tasks constants
-const CONSTANTS = {
-  SDK_READY: 'Getting ready - Split SDK',
-  SDK_GET_TREATMENT: 'SDK - Get Treatment',
-  SDK_GET_TREATMENTS: 'SDK - Get Treatments',
-  SDK_GET_TREATMENT_WITH_CONFIG: 'SDK - Get Treatment with config',
-  SDK_GET_TREATMENTS_WITH_CONFIG: 'SDK - Get Treatments with config',
-  SPLITS_READY: 'Getting ready - Splits',
-  SEGMENTS_READY: 'Getting ready - Segments',
-  METRICS_PUSH: 'Pushing - Metrics',
-  IMPRESSIONS_PUSH: 'Pushing - Impressions',
-  EVENTS_PUSH: 'Pushing - Events',
-  MY_SEGMENTS_FETCH: 'Fetching - My Segments',
-  SEGMENTS_FETCH: 'Fetching - Segments',
-  SPLITS_FETCH: 'Fetching - Splits'
-};
-// Tasks callbacks, if any
-const CALLBACKS = {
-  [CONSTANTS.SDK_READY]: {
-    collector: 'client',
-    method: 'ready'
-  },
-  [CONSTANTS.SDK_GET_TREATMENT]: {
-    collector: 'client',
-    method: 'getTreatment'
-  },
-  [CONSTANTS.SDK_GET_TREATMENTS]: {
-    collector: 'client',
-    method: 'getTreatments'
-  },
-  [CONSTANTS.SDK_GET_TREATMENT_WITH_CONFIG]: {
-    collector: 'client',
-    method: 'getTreatmentWithConfig'
-  },
-  [CONSTANTS.SDK_GET_TREATMENTS_WITH_CONFIG]: {
-    collector: 'client',
-    method: 'getTreatmentsWithConfig'
-  },
-  [CONSTANTS.MY_SEGMENTS_FETCH]: {
-    collector: 'mySegments',
-    method: 'latency'
-  },
-  [CONSTANTS.SEGMENTS_FETCH]: {
-    collector: 'segmentChanges',
-    method: 'latency'
-  },
-  [CONSTANTS.SPLITS_FETCH]: {
-    collector: 'splitChanges',
-    method: 'latency'
-  }
-};
-/**
- * Generates the timer keys using the task name and a modifier, if any.
- * @param {string} task - The task name
- * @param {number | string} modifier - (optional) The modifier, if any.
- * @return {string} The generated timer key
- */
-function generateTimerKey(task: string, modifier?: number | string) { return modifier ? task + modifier : task; }
-/**
- * Given the collectors map, it returns the specific collector for a given task.
- *
- * @param {string} task - The task name
- * @param {Object} collectors - The collectors map
- */
-function getCollectorForTask(task: string, collectors?: Record<string, MetricsCollector>): false | MetricsCollector {
-  const callbackData = CALLBACKS[task];
-
-  if (callbackData && collectors) return collectors[callbackData.collector];
-
-  return false;
-}
-/**
- * Given a collector and a task, returns the callback function that should be called when we stop the timer.
- *
- * @param {string} task - The task name
- * @param {Object} collector - The collector object for the task
- */
-function getCallbackForTask(task: string, collector: MetricsCollector | false): ((ms: number) => void) | false {
-  const callbackData = CALLBACKS[task];
-
-  if (callbackData && collector) return collector[callbackData.method];
-
-  return false;
-}
-
-// Our "time tracker" API
-export const TrackerAPI = {
-  /**
-   * "Private" method, used to attach count/countException and stop callbacks to a promise.
-   *
-   * @param {ILogger} log - Logger.
-   * @param {Promise} promise - The promise we want to attach the callbacks.
-   * @param {string} task - The name of the task.
-   * @param {number | string} modifier - (optional) The modifier for the task, if any.
-   */
-  __attachToPromise(log: ILogger, promise: Promise<IResponse>, task: string, collector: false | MetricsCollector, modifier?: number | string) {
-    return promise.then(resp => {
-      this.stop(log, task, modifier);
-
-      if (collector && collector.count) collector.count(resp.status);
-
-      return resp;
-    })
-      .catch(err => {
-        this.stop(log, task, modifier);
-
-        if (collector && collector.countException) collector.countException();
-
-        throw err;
-      });
-  },
-  /**
-   * Starts tracking the time for a given task. All tasks tracked are considered "unique" because
-   * there may be multiple SDK instances tracking a "generic" task, making any task non-generic.
-   *
-   * @param {ILogger} log - Logger.
-   * @param {string} task - The task we are starting.
-   * @param {Object} collectors - The collectors map.
-   * @param {Promise} promise - (optional) The promise we are tracking.
-   * @return {Function | Promise} The stop function for this specific task or the promise received with the callbacks registered.
-   */
-  start(log: ILogger, task: string, collectors?: Record<string, MetricsCollector>, promise?: Promise<IResponse>, now: () => number = Date.now): Promise<IResponse> | (() => number) {
-    const taskUniqueId = uniqueId();
-    const taskCollector = getCollectorForTask(task, collectors);
-    let result;
-
-    // If we are registering a promise with this task, we should count the status and the exceptions as well
-    // as stopping the task when the promise resolves. Then return the promise
-    if (thenable(promise)) {
-      result = this.__attachToPromise(log, promise, task, taskCollector, taskUniqueId);
-    } else {
-      // If not, we return the stop function, as it will be stopped manually.
-      result = this.stop.bind(this, log, task, taskUniqueId);
-      if (CALLBACKS[task] && !taskCollector) {
-        // and provide a way for a defered setup of the collector, if needed.
-        // @ts-expect-error
-        result.setCollectorForTask = this.setCollectorForTask.bind(this, task, taskUniqueId);
-      }
-    }
-
-    // We start the timer, with an uniqueId attached to it's name, and save tracking info for this task.
-    const trackingKey = generateTimerKey(task, taskUniqueId);
-    const cb = getCallbackForTask(task, taskCollector);
-    timers[trackingKey] = {
-      cb,
-      timer: timer(now)
-    };
-
-    return result as () => number;
-  },
-  /**
-   * Setup the collector for a task that reports metrics.
-   *
-   * @param {string} task - The task name
-   * @param {number | string} taskUniqueId - The unique identifier for this task
-   * @param {Object} collectors - The collectors map.
-   */
-  setCollectorForTask(task: string, taskUniqueId: number | string, collectors: Record<string, MetricsCollector>) {
-    const taskCollector = getCollectorForTask(task, collectors);
-
-    if (taskCollector) {
-      const trackingKey = generateTimerKey(task, taskUniqueId);
-      timers[trackingKey].cb = getCallbackForTask(task, taskCollector);
-    }
-  },
-  /**
-   * Stops the tracking of a given task.
-   *
-   * @param {ILogger} log - Logger.
-   * @param {string} task - The task we are starting.
-   * @param {number | string} modifier - (optional) The modifier for that specific task.
-   */
-  stop(log: ILogger, task: string, modifier?: number | string) {
-    const timerName = generateTimerKey(task, modifier);
-    const timerData = timers[timerName];
-    if (timerData) {
-      // Stop the timer and round result for readability.
-      const et = timerData.timer();
-      log.debug(`[TIME TRACKER]: [${task}] took ${et}ms to finish.`);
-
-      // Check if we have a tracker callback.
-      if (timerData.cb) {
-        // If we have a callback, we call it with the elapsed time of the task and then delete the reference.
-        timerData.cb(et);
-      }
-
-      // Remove the task tracking reference.
-      delete timers[timerName];
-
-      return et;
-    }
-  },
-  /**
-   * The constants shortcut for the task names.
-   */
-  TaskNames: CONSTANTS
-};