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

package/src/sync/submitters/types.ts

@@ -62,3 +62,126 @@ export type StoredEventWithMetadata = {
   /** Stored event */
   e: SplitIO.EventData
 }
+
+/**
+ * Telemetry usage stats
+ */
+
+export type QUEUED = 0;
+export type DROPPED = 1;
+export type DEDUPED = 2;
+export type ImpressionDataType = QUEUED | DROPPED | DEDUPED
+export type EventDataType = QUEUED | DROPPED;
+
+export type SPLITS = 'sp';
+export type IMPRESSIONS = 'im';
+export type IMPRESSIONS_COUNT = 'ic';
+export type EVENTS = 'ev';
+export type TELEMETRY = 'te';
+export type TOKEN = 'to';
+export type SEGMENT = 'se';
+export type MY_SEGMENT = 'ms';
+export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
+
+export type LastSync = Record<OperationType, number | undefined>
+export type HttpErrors = Record<OperationType, { [statusCode: string]: number }>
+export type HttpLatencies = Record<OperationType, Array<number>>
+
+export type TREATMENT = 't';
+export type TREATMENTS = 'ts';
+export type TREATMENT_WITH_CONFIG = 'tc';
+export type TREATMENTS_WITH_CONFIG = 'tcs';
+export type TRACK = 'tr';
+export type Method = TREATMENT | TREATMENTS | TREATMENT_WITH_CONFIG | TREATMENTS_WITH_CONFIG | TRACK;
+
+export type MethodLatencies = Record<Method, Array<number>>;
+
+export type MethodExceptions = Record<Method, number>;
+
+export type CONNECTION_ESTABLISHED = 0;
+export type OCCUPANCY_PRI = 10;
+export type OCCUPANCY_SEC = 20;
+export type STREAMING_STATUS = 30;
+export type SSE_CONNECTION_ERROR = 40;
+export type TOKEN_REFRESH = 50;
+export type ABLY_ERROR = 60;
+export type SYNC_MODE_UPDATE = 70;
+export type StreamingEventType = CONNECTION_ESTABLISHED | OCCUPANCY_PRI | OCCUPANCY_SEC | STREAMING_STATUS | SSE_CONNECTION_ERROR | TOKEN_REFRESH | ABLY_ERROR | SYNC_MODE_UPDATE;
+
+export type StreamingEvent = {
+  e: StreamingEventType, // eventType
+  d?: number, // eventData
+  t: number, // timestamp
+}
+
+// 'metrics/usage' JSON request body
+export type TelemetryUsageStatsPayload = {
+  lS: LastSync, // lastSynchronization
+  mL: MethodLatencies, // clientMethodLatencies
+  mE: MethodExceptions, // methodExceptions
+  hE: HttpErrors, // httpErrors
+  hL: HttpLatencies, // httpLatencies
+  tR: number, // tokenRefreshes
+  aR: number, // authRejections
+  iQ: number, // impressionsQueued
+  iDe: number, // impressionsDeduped
+  iDr: number, // impressionsDropped
+  spC: number, // splitCount
+  seC: number, // segmentCount
+  skC: number, // segmentKeyCount
+  sL?: number, // sessionLengthMs
+  eQ: number, // eventsQueued
+  eD: number, // eventsDropped
+  sE: Array<StreamingEvent>, // streamingEvents
+  t?: Array<string>, // tags
+}
+
+/**
+ * Telemetry config stats
+ */
+
+export type STANDALONE_ENUM = 0;
+export type CONSUMER_ENUM = 1;
+export type CONSUMER_PARTIAL_ENUM = 2;
+export type OperationMode = STANDALONE_ENUM | CONSUMER_ENUM | CONSUMER_PARTIAL_ENUM
+
+export type OPTIMIZED_ENUM = 0;
+export type DEBUG_ENUM = 1;
+export type ImpressionsMode = OPTIMIZED_ENUM | DEBUG_ENUM;
+
+export type RefreshRates = {
+  sp: number, // splits
+  se: number, // mySegments
+  im: number, // impressions
+  ev: number, // events
+  te: number, // telemetry
+}
+
+export type UrlOverrides = {
+  s: boolean, // sdkUrl
+  e: boolean, // events
+  a: boolean, // auth
+  st: boolean, // stream
+  t: boolean, // telemetry
+}
+
+// 'metrics/config' JSON request body
+export type TelemetryConfigStatsPayload = {
+  oM?: OperationMode, // operationMode
+  st: 'memory' | 'redis' | 'pluggable' | 'localstorage', // storage
+  sE: boolean, // streamingEnabled
+  rR: RefreshRates, // refreshRates
+  uO: UrlOverrides, // urlOverrides
+  iQ: number, // impressionsQueueSize
+  eQ: number, // eventsQueueSize
+  iM: ImpressionsMode, // impressionsMode
+  iL: boolean, // impressionsListenerEnabled
+  hP: boolean, // httpProxyDetected
+  aF: number, // activeFactories
+  rF: number, // redundantActiveFactories
+  tR: number, // timeUntilSDKReady
+  tC?: number, // timeUntilSDKReadyFromCache
+  nR: number, // SDKNotReadyUsage
+  t?: Array<string>, // tags
+  i?: Array<string>, // integrations
+}

package/src/sync/syncManagerOnline.ts

@@ -1,4 +1,4 @@
-import { ISyncManagerCS, ISyncManagerFactoryParams } from './types';
+import { ISyncManagerCS } from './types';
 import { submitterManagerFactory } from './submitters/submitterManager';
 import { IReadinessManager } from '../readiness/types';
 import { IStorageSync } from '../storages/types';
@@ -7,6 +7,8 @@ import { IPollingManager, IPollingManagerCS } from './polling/types';
 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';
+import { ISdkFactoryContextSync } from '../sdkFactory/types';
 
 /**
  * Online SyncManager factory.
@@ -17,16 +19,16 @@ import { isConsentGranted } from '../consent';
  * @param pushManagerFactory optional to build a SyncManager with or without streaming support
  */
 export function syncManagerOnlineFactory(
-  pollingManagerFactory?: (params: ISyncManagerFactoryParams) => IPollingManager,
-  pushManagerFactory?: (params: ISyncManagerFactoryParams, pollingManager: IPollingManager) => IPushManager | undefined,
-): (params: ISyncManagerFactoryParams) => ISyncManagerCS {
+  pollingManagerFactory?: (params: ISdkFactoryContextSync) => IPollingManager,
+  pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined,
+): (params: ISdkFactoryContextSync) => ISyncManagerCS {
 
   /**
    * SyncManager factory for modular SDK
    */
-  return function (params: ISyncManagerFactoryParams): ISyncManagerCS {
+  return function (params: ISdkFactoryContextSync): ISyncManagerCS {
 
-    const { settings, settings: { log, streamingEnabled } } = params;
+    const { settings, settings: { log, streamingEnabled }, telemetryTracker } = params;
 
     /** Polling Manager */
     const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
@@ -48,13 +50,17 @@ export function syncManagerOnlineFactory(
       } 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()) pollingManager!.stop();
+      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/src/sync/types.ts

@@ -1,8 +1,5 @@
 import { IReadinessManager } from '../readiness/types';
-import { IPlatform } from '../sdkFactory/types';
-import { ISplitApi } from '../services/types';
 import { IStorageSync } from '../storages/types';
-import { ISettings } from '../types';
 import { IPollingManager } from './polling/types';
 import { IPushManager } from './streaming/types';
 
@@ -36,10 +33,6 @@ export interface ISyncTask<Input extends any[] = [], Output = any> extends ITask
   isExecuting(): boolean
 }
 
-export interface ITimeTracker {
-  start(): () => void // start tracking time and return a function to call for stopping the tracking
-}
-
 /** SyncManager */
 
 export interface ISyncManager extends ITask {
@@ -52,11 +45,3 @@ export interface ISyncManager extends ITask {
 export interface ISyncManagerCS extends ISyncManager {
   shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined
 }
-
-export interface ISyncManagerFactoryParams {
-  settings: ISettings,
-  readiness: IReadinessManager,
-  storage: IStorageSync,
-  splitApi: ISplitApi,
-  platform: IPlatform
-}

package/src/trackers/eventTracker.ts

@@ -1,10 +1,10 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
-import { IEventsCacheBase } from '../storages/types';
+import { IEventsCacheBase, ITelemetryCacheAsync, ITelemetryCacheSync } from '../storages/types';
 import { IEventsHandler, IEventTracker } from './types';
 import { ISettings, SplitIO } from '../types';
 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';
 
 /**
@@ -16,7 +16,8 @@ import { isStorageSync } from './impressionObserver/utils';
 export function eventTrackerFactory(
   settings: ISettings,
   eventsCache: IEventsCacheBase,
-  integrationsManager?: IEventsHandler
+  integrationsManager?: IEventsHandler,
+  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
 ): IEventTracker {
 
   const log = settings.log;
@@ -57,6 +58,9 @@ export function eventTrackerFactory(
       if (thenable(tracked)) {
         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 as ITelemetryCacheSync).recordEventStats(tracked ? QUEUED : DROPPED, 1);
         return queueEventsCallback(eventData, tracked);
       }
     }

package/src/trackers/impressionsTracker.ts

@@ -1,12 +1,12 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { truncateTimeFrame } from '../utils/time';
-import { IImpressionCountsCacheSync, IImpressionsCacheBase } from '../storages/types';
+import { IImpressionCountsCacheSync, IImpressionsCacheBase, ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
 import { IImpressionsHandler, IImpressionsTracker } from './types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
 import { IImpressionObserver } from './impressionObserver/types';
 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.
@@ -25,7 +25,8 @@ export function impressionsTrackerFactory(
   // if observer is provided, it implies `shouldAddPreviousTime` flag (i.e., if impressions previous time should be added or not)
   observer?: IImpressionObserver,
   // if countsCache is provided, it implies `isOptimized` flag (i.e., if impressions should be deduped or not)
-  countsCache?: IImpressionCountsCacheSync
+  countsCache?: IImpressionCountsCacheSync,
+  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
 ): IImpressionsTracker {
 
   const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
@@ -65,6 +66,13 @@ export function impressionsTrackerFactory(
         }).catch(err => {
           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 as ITelemetryCacheSync).recordImpressionStats(QUEUED, impressionsToStore.length);
+          (telemetryCache as ITelemetryCacheSync).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

package/src/trackers/telemetryTracker.ts

@@ -0,0 +1,63 @@
+import { ITelemetryCacheSync, ITelemetryCacheAsync } from '../storages/types';
+import { EXCEPTION, SDK_NOT_READY } from '../utils/labels';
+import { ITelemetryTracker } from './types';
+import { timer } from '../utils/timeTracker/timer';
+import { TOKEN_REFRESH, AUTH_REJECTION } from '../utils/constants';
+
+export function telemetryTrackerFactory(
+  telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
+  now?: () => number
+): ITelemetryTracker {
+
+  if (telemetryCache && now) {
+    const startTime = timer(now);
+
+    return {
+      trackEval(method) {
+        const evalTime = timer(now);
+
+        return (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(operation) {
+        const httpTime = timer(now);
+
+        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());
+        };
+      },
+      sessionLength() { // @ts-ignore ITelemetryCacheAsync doesn't implement the method
+        if (telemetryCache.recordSessionLength) telemetryCache.recordSessionLength(startTime());
+      },
+      streamingEvent(e, d) {
+        if (e === AUTH_REJECTION) {
+          (telemetryCache as ITelemetryCacheSync).recordAuthRejections();
+        } else {
+          (telemetryCache as ITelemetryCacheSync).recordStreamingEvents({
+            e, d, t: now()
+          });
+          if (e === TOKEN_REFRESH) (telemetryCache as ITelemetryCacheSync).recordTokenRefreshes();
+        }
+      }
+    };
+
+  } else { // If there is not `telemetryCache` or `now` time tracker, return a no-op telemetry tracker
+    const noopTrack = () => () => { };
+    return {
+      trackEval: noopTrack,
+      trackHttp: noopTrack,
+      sessionLength: () => { },
+      streamingEvent: () => { },
+    };
+  }
+}

package/src/trackers/types.ts

@@ -1,5 +1,7 @@
 import { SplitIO, ImpressionDTO } from '../types';
+import { StreamingEventType, Method, OperationType } from '../sync/submitters/types';
 import { IEventsCacheBase } from '../storages/types';
+import { NetworkError } from '../services/types';
 
 /** Events tracker */
 
@@ -18,3 +20,25 @@ export interface IImpressionsHandler {
 export interface IImpressionsTracker {
   track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes): void
 }
+
+/** Telemetry tracker */
+export type AUTH_REJECTION = 80;
+
+export interface ITelemetryTracker {
+  /**
+   * Creates a telemetry evaluator tracker, to record Latencies, Exceptions and NonReadyUsage of client operations (getTreatments and track method calls)
+   */
+  trackEval(method: Method): (label?: string) => void
+  /**
+   * Creates a telemetry runtime tracker, to record Latencies and Exceptions of HTTP requests
+   */
+  trackHttp(method: OperationType): (error?: NetworkError) => void
+  /**
+   * Records session length
+   */
+  sessionLength(): void
+  /**
+   * Records streaming event
+   */
+  streamingEvent(e: StreamingEventType | AUTH_REJECTION, d?: number): void
+}

package/src/types.ts

@@ -1,10 +1,11 @@
 import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
+import { ISdkFactoryContext } from './sdkFactory/types';
 /* eslint-disable no-use-before-define */
 
 import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
-import { ISyncManagerFactoryParams, ISyncManagerCS } from './sync/types';
+import { ISyncManagerCS } from './sync/types';
 
 /**
  * Reduced version of NodeJS.EventEmitter interface with the minimal methods used by the SDK
@@ -79,7 +80,11 @@ export interface ISettings {
     featuresRefreshRate: number,
     impressionsRefreshRate: number,
     impressionsQueueSize: number,
-    metricsRefreshRate: number,
+    /**
+     * @deprecated
+     */
+    metricsRefreshRate?: number,
+    telemetryRefreshRate: number,
     segmentsRefreshRate: number,
     offlineRefreshRate: number,
     eventsPushRate: number,
@@ -93,12 +98,16 @@ export interface ISettings {
     eventsFirstPushWindow: number
   },
   readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
-  readonly integrations?: Array<(params: IIntegrationFactoryParams) => IIntegration | void>,
+  readonly integrations: Array<{
+    readonly type: string,
+    (params: IIntegrationFactoryParams): IIntegration | void
+  }>,
   readonly urls: {
     events: string,
     sdk: string,
     auth: string,
-    streaming: string
+    streaming: string,
+    telemetry: string
   },
   readonly debug: boolean | LogLevel | ILogger,
   readonly version: string,
@@ -273,8 +282,15 @@ interface INodeBasicSettings extends ISharedSettings {
      * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
      * @property {number} metricsRefreshRate
      * @default 120
+     * @deprecated This parameter is ignored now.
      */
     metricsRefreshRate?: number,
+    /**
+     * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
+     * @property {number} telemetryRefreshRate
+     * @default 3600
+     */
+    telemetryRefreshRate?: number,
     /**
      * The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds.
      * @property {number} segmentsRefreshRate
@@ -607,7 +623,7 @@ export namespace SplitIO {
    */
   export type LocalhostFactory = {
     type: 'LocalhostFromObject' | 'LocalhostFromFile'
-    (params: ISyncManagerFactoryParams): ISyncManagerCS
+    (params: ISdkFactoryContext): ISyncManagerCS
   }
   /**
    * Impression listener interface. This is the interface that needs to be implemented
@@ -664,7 +680,13 @@ export namespace SplitIO {
      * @property {string} streaming
      * @default 'https://streaming.split.io'
      */
-    streaming?: string
+    streaming?: string,
+    /**
+     * String property to override the base URL where the SDK will post telemetry data.
+     * @property {string} telemetry
+     * @default 'https://telemetry.split.io/api'
+     */
+    telemetry?: string
   };
   /**
    * SplitFilter type.
@@ -794,8 +816,15 @@ export namespace SplitIO {
        * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
        * @property {number} metricsRefreshRate
        * @default 120
+       * @deprecated This parameter is ignored now.
        */
       metricsRefreshRate?: number,
+      /**
+       * The SDK sends diagnostic metrics to Split servers. This parameters controls this metric flush period in seconds.
+       * @property {number} telemetryRefreshRate
+       * @default 3600
+       */
+      telemetryRefreshRate?: number,
       /**
        * The SDK polls Split servers for changes to segment definitions. This parameter controls this polling period in seconds.
        * @property {number} segmentsRefreshRate

package/src/utils/constants/index.ts

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

package/src/utils/inputValidation/apiKey.ts

@@ -21,7 +21,8 @@ export function validateApiKey(log: ILogger, maybeApiKey: any): string | false {
   return apiKey;
 }
 
-const usedKeysMap: Record<string, number> = {};
+// Exported for telemetry
+export const usedKeysMap: Record<string, number> = {};
 
 /** validates the given api key and also warns if it is in use */
 export function validateAndTrackApiKey(log: ILogger, maybeApiKey: any): string | false {

package/src/utils/settingsValidation/index.ts

@@ -1,14 +1,16 @@
 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 { ISettingsValidationParams } from './types';
 import { ISettings } from '../../types';
 import { validateKey } from '../inputValidation/key';
 import { validateTrafficType } from '../inputValidation/trafficType';
+import { ERROR_MIN_CONFIG_PARAM } from '../../logger/constants';
 
-const base = {
+// Exported for telemetry
+export const base = {
   // Define which kind of object you want to retrieve from SplitFactory
   mode: STANDALONE_MODE,
 
@@ -30,10 +32,10 @@ const 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
@@ -55,6 +57,8 @@ const 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.
@@ -109,14 +113,37 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   const 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: string, actualValue: number, minValue: number) {
+    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
   const { scheduler, startup } = withDefaults;
   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);
@@ -176,9 +203,6 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   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/src/utils/settingsValidation/url.ts

@@ -1,5 +1,6 @@
 import { ISettings } from '../../types';
 
+const telemetryEndpointMatcher = /^\/v1\/metrics\/(config|usage)/;
 const eventsEndpointMatcher = /^\/(testImpressions|metrics|events)/;
 const authEndpointMatcher = /^\/v2\/auth/;
 const streamingEndpointMatcher = /^\/(sse|event-stream)/;
@@ -13,6 +14,9 @@ const streamingEndpointMatcher = /^\/(sse|event-stream)/;
  * @return complete url
  */
 export function url(settings: ISettings, target: string) {
+  if (telemetryEndpointMatcher.test(target)) {
+    return `${settings.urls.telemetry}${target}`;
+  }
   if (eventsEndpointMatcher.test(target)) {
     return `${settings.urls.events}${target}`;
   }

package/src/utils/timeTracker/index.ts

@@ -148,7 +148,7 @@ export const TrackerAPI = {
    * @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): Promise<IResponse> | (() => number) {
+  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;