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

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,10 +25,11 @@ 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 } } = settings;
+  const { log, impressionListener, runtime: { ip, hostname }, version } = settings;
 
   return {
     track(impressions: ImpressionDTO[], attributes?: SplitIO.Attributes) {
@@ -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
@@ -76,7 +84,7 @@ export function impressionsTrackerFactory(
             attributes,
             ip,
             hostname,
-            sdkLanguageVersion: settings.version
+            sdkLanguageVersion: version
           };
 
           // Wrap in a timeout because we don't want it to be blocking.

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
+              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() {
+        (telemetryCache as ITelemetryCacheSync).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'
+     */
+    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

@@ -7,8 +7,10 @@ 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,8 +32,8 @@ const base = {
     featuresRefreshRate: 30,
     // fetch segments updates each 60 sec
     segmentsRefreshRate: 60,
-    // publish metrics each 120 sec
-    metricsRefreshRate: 120,
+    // publish telemetry stats each 3600 secs (1 hour)
+    telemetryRefreshRate: 3600,
     // publish evaluations each 60 sec
     impressionsRefreshRate: 60,
     // fetch offline changes each 15 sec
@@ -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',
   },
 
   // Defines which kind of storage we should instanciate.
@@ -109,14 +113,24 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   const log = logger(withDefaults); // @ts-ignore, modify readonly prop
   withDefaults.log = log;
 
+  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));
+
+  // 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);

package/src/utils/settingsValidation/url.ts

@@ -1,5 +1,6 @@
 import { ISettings } from '../../types';
 
+const telemetryEndpointMatcher = /^\/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;

package/src/utils/timeTracker/timer.ts

@@ -1,7 +1,7 @@
-export function timer(now?: () => number) {
-  const st = now ? now() : Date.now();
+export function timer(now: () => number) {
+  const st = now();
 
   return function stop() {
-    return Math.round(now ? now() : Date.now() - st);
+    return Math.round(now() - st);
   };
 }

package/types/logger/constants.d.ts

@@ -120,6 +120,7 @@ export declare const ERROR_HTTP = 322;
 export declare const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 export declare const ERROR_STORAGE_INVALID = 324;
 export declare const ERROR_NOT_BOOLEAN = 325;
+export declare const ERROR_MIN_CONFIG_PARAM = 326;
 export declare const LOG_PREFIX_SETTINGS = "settings";
 export declare const LOG_PREFIX_INSTANTIATION = "Factory instantiation";
 export declare const LOG_PREFIX_ENGINE = "engine";

package/types/sdkFactory/types.d.ts

@@ -1,22 +1,13 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
 import { ILogger } from '../logger/types';
-import { ISdkReadinessManager } from '../readiness/types';
+import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
-import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
+import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker } from '../trackers/types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
-export interface ISdkFactoryContext {
-    storage: IStorageSync | IStorageAsync;
-    sdkReadinessManager: ISdkReadinessManager;
-    settings: ISettings;
-    impressionsTracker: IImpressionsTracker;
-    eventTracker: IEventTracker;
-    signalListener?: ISignalListener;
-    syncManager?: ISyncManager;
-}
 /**
  * Environment related dependencies.
  * These getters are called a fixed number of times per factory instantiation.
@@ -26,6 +17,30 @@ export interface IPlatform {
     getFetch?: () => (IFetch | undefined);
     getEventSource?: () => (IEventSourceConstructor | undefined);
     EventEmitter: new () => IEventEmitter;
+    now?: () => number;
+}
+export interface ISdkFactoryContext {
+    platform: IPlatform;
+    sdkReadinessManager: ISdkReadinessManager;
+    readiness: IReadinessManager;
+    settings: ISettings;
+    impressionsTracker: IImpressionsTracker;
+    eventTracker: IEventTracker;
+    telemetryTracker: ITelemetryTracker;
+    storage: IStorageSync | IStorageAsync;
+    signalListener?: ISignalListener;
+    splitApi?: ISplitApi;
+    syncManager?: ISyncManager;
+}
+export interface ISdkFactoryContextSync extends ISdkFactoryContext {
+    storage: IStorageSync;
+    splitApi: ISplitApi;
+    syncManager: ISyncManager;
+}
+export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
+    storage: IStorageAsync;
+    splitApi: undefined;
+    syncManager: undefined;
 }
 /**
  * Object parameter with the modules required to create an SDK factory instance
@@ -35,7 +50,7 @@ export interface ISdkFactoryParams {
     platform: IPlatform;
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;
     splitApiFactory?: (settings: ISettings, platform: IPlatform) => ISplitApi;
-    syncManagerFactory?: (params: ISyncManagerFactoryParams) => ISyncManager;
+    syncManagerFactory?: (params: ISdkFactoryContextSync) => ISyncManager;
     sdkManagerFactory: (log: ILogger, splits: ISplitsCacheSync | ISplitsCacheAsync, sdkReadinessManager: ISdkReadinessManager) => SplitIO.IManager | SplitIO.IAsyncManager;
     sdkClientMethodFactory: (params: ISdkFactoryContext) => ({
         (): SplitIO.ICsClient;

package/types/services/splitApi.d.ts

@@ -1,10 +1,11 @@
 import { IPlatform } from '../sdkFactory/types';
 import { ISettings } from '../types';
 import { ISplitApi } from './types';
+import { ITelemetryTracker } from '../trackers/types';
 /**
  * Factory of SplitApi objects, which group the collection of Split HTTP endpoints used by the SDK
  *
  * @param settings validated settings object
  * @param platform object containing environment-specific `getFetch` and `getOptions` dependencies
  */
-export declare function splitApiFactory(settings: Pick<ISettings, 'urls' | 'sync' | 'log' | 'version' | 'runtime' | 'core'>, platform: Pick<IPlatform, 'getFetch' | 'getOptions'>): ISplitApi;
+export declare function splitApiFactory(settings: Pick<ISettings, 'urls' | 'sync' | 'log' | 'version' | 'runtime' | 'core'>, platform: Pick<IPlatform, 'getFetch' | 'getOptions'>, telemetryTracker: ITelemetryTracker): ISplitApi;

package/types/services/types.d.ts

@@ -9,9 +9,12 @@ export declare type IResponse = {
     json: () => Promise<any>;
     text: () => Promise<string>;
 };
+export declare type NetworkError = Error & {
+    statusCode?: number;
+};
 export declare type IFetch = (url: string, options?: IRequestOptions) => Promise<IResponse>;
 export declare type IHealthCheckAPI = () => Promise<boolean>;
-export declare type ISplitHttpClient = (url: string, options?: IRequestOptions, logErrorsAsInfo?: boolean) => Promise<IResponse>;
+export declare type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean) => Promise<IResponse>;
 export declare type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>;
 export declare type IFetchSplitChanges = (since: number, noCache?: boolean) => Promise<IResponse>;
 export declare type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean) => Promise<IResponse>;
@@ -19,8 +22,8 @@ export declare type IFetchMySegments = (userMatchingKey: string, noCache?: boole
 export declare type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostTestImpressionsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
-export declare type IPostMetricsCounters = (body: string) => Promise<IResponse>;
-export declare type IPostMetricsTimes = (body: string) => Promise<IResponse>;
+export declare type IPostMetricsConfig = (body: string) => Promise<IResponse>;
+export declare type IPostMetricsUsage = (body: string) => Promise<IResponse>;
 export interface ISplitApi {
     getSdkAPIHealthCheck: IHealthCheckAPI;
     getEventsAPIHealthCheck: IHealthCheckAPI;
@@ -31,8 +34,8 @@ export interface ISplitApi {
     postEventsBulk: IPostEventsBulk;
     postTestImpressionsBulk: IPostTestImpressionsBulk;
     postTestImpressionsCount: IPostTestImpressionsCount;
-    postMetricsCounters: IPostMetricsCounters;
-    postMetricsTimes: IPostMetricsTimes;
+    postMetricsConfig: IPostMetricsConfig;
+    postMetricsUsage: IPostMetricsUsage;
 }
 interface EventSourceEventMap {
     'error': Event;