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

package/src/sync/streaming/SSEHandler/index.ts

@@ -6,18 +6,8 @@ import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
 import { ILogger } from '../../../logger/types';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
-
-function isRetryableError(error: INotificationError) {
-  if (error.parsedData && error.parsedData.code) {
-    const code = error.parsedData.code;
-    // 401 errors due to invalid or expired token (e.g., if refresh token coudn't be executed)
-    if (40140 <= code && code <= 40149) return true;
-    // Others 4XX errors (e.g., bad request from the SDK)
-    if (40000 <= code && code <= 49999) return false;
-  }
-  // network errors or 5XX HTTP errors
-  return true;
-}
+import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
+import { ITelemetryTracker } from '../../../trackers/types';
 
 /**
  * Factory for SSEHandler, which processes SSEClient messages and emits the corresponding push events.
@@ -25,9 +15,26 @@ function isRetryableError(error: INotificationError) {
  * @param log factory logger
  * @param pushEmitter emitter for events related to streaming support
  */
-export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter): ISseEventHandler {
+export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter, telemetryTracker: ITelemetryTracker): ISseEventHandler {
 
-  const notificationKeeper = notificationKeeperFactory(pushEmitter);
+  const notificationKeeper = notificationKeeperFactory(pushEmitter, telemetryTracker);
+
+  function isRetryableError(error: INotificationError): boolean {
+    if (error.parsedData && error.parsedData.code) {
+      // Ably error
+      const code = error.parsedData.code;
+      telemetryTracker.streamingEvent(ABLY_ERROR, code);
+
+      // 401 errors due to invalid or expired token (e.g., if refresh token coudn't be executed)
+      if (40140 <= code && code <= 40149) return true;
+      // Others 4XX errors (e.g., bad request from the SDK)
+      if (40000 <= code && code <= 49999) return false;
+    } else {
+      // network errors or 5XX HTTP errors
+      telemetryTracker.streamingEvent(SSE_CONNECTION_ERROR, NON_REQUESTED);
+    }
+    return true;
+  }
 
   return {
     handleOpen() {

package/src/sync/streaming/pushManager.ts

@@ -18,7 +18,8 @@ import { isInBitmap, parseBitmap, parseKeyList } from './mySegmentsV2utils';
 import { ISet, _Set } from '../../utils/lang/sets';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
-import { ISyncManagerFactoryParams } from '../types';
+import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
 /**
  * PushManager factory:
@@ -26,11 +27,11 @@ import { ISyncManagerFactoryParams } from '../types';
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
 export function pushManagerFactory(
-  params: ISyncManagerFactoryParams,
+  params: ISdkFactoryContextSync,
   pollingManager: IPollingManager,
 ): IPushManager | undefined {
 
-  const { settings, storage, splitApi, readiness, platform } = params;
+  const { settings, storage, splitApi, readiness, platform, telemetryTracker } = params;
 
   // `userKey` is the matching key of main client in client-side SDK.
   // It can be used to check if running on client-side or server-side SDK.
@@ -49,7 +50,7 @@ export function pushManagerFactory(
 
   // init feedback loop
   const pushEmitter = new platform.EventEmitter() as IPushEventEmitter;
-  const sseHandler = SSEHandlerFactory(log, pushEmitter);
+  const sseHandler = SSEHandlerFactory(log, pushEmitter, telemetryTracker);
   sseClient.setEventHandler(sseHandler);
 
   // init workers
@@ -101,6 +102,8 @@ export function pushManagerFactory(
       if (disconnected) return;
       sseClient.open(authData);
     }, connDelay * 1000);
+
+    telemetryTracker.streamingEvent(TOKEN_REFRESH, decodedToken.exp);
   }
 
   function connectPush() {
@@ -137,6 +140,7 @@ export function pushManagerFactory(
 
         // Handle 4XX HTTP errors: 401 (invalid API Key) or 400 (using incorrect API Key, i.e., client-side API Key on server-side)
         if (error.statusCode >= 400 && error.statusCode < 500) {
+          telemetryTracker.streamingEvent(AUTH_REJECTION);
           pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
           return;
         }
@@ -179,7 +183,7 @@ export function pushManagerFactory(
     stopWorkers();
   });
 
-  /** Fallbacking without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
+  /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
 
   pushEmitter.on(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
     disabled = true;
@@ -188,7 +192,7 @@ export function pushManagerFactory(
     pushEmitter.emit(PUSH_SUBSYSTEM_DOWN); // no harm if polling already
   });
 
-  /** Fallbacking with retry due to recoverable SSE and Authentication errors */
+  /** Fallback to polling with retry due to recoverable SSE and Authentication errors */
 
   pushEmitter.on(PUSH_RETRYABLE_ERROR, function handleRetryableError() { // HTTP or network error in SSE connection
     // SSE connection is closed to avoid repeated errors due to retries
@@ -316,7 +320,7 @@ export function pushManagerFactory(
       },
 
       // true/false if start or stop was called last respectively
-      isRunning(){
+      isRunning() {
         return disconnected === false;
       },
 

package/src/sync/submitters/eventsSubmitter.ts

@@ -0,0 +1,35 @@
+import { submitterFactory, firstPushWindowDecorator } from './submitter';
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+
+const DATA_NAME = 'events';
+
+/**
+ * Submitter that periodically posts tracked events
+ */
+export function eventsSubmitterFactory(params: ISdkFactoryContextSync) {
+
+  const {
+    settings: { log, scheduler: { eventsPushRate }, startup: { eventsFirstPushWindow } },
+    splitApi: { postEventsBulk },
+    storage: { events },
+  } = params;
+
+  // don't retry events.
+  let submitter = submitterFactory(log, postEventsBulk, events, eventsPushRate, DATA_NAME);
+
+  // Set a timer for the first push window of events.
+  if (eventsFirstPushWindow > 0) submitter = firstPushWindowDecorator(submitter, eventsFirstPushWindow);
+
+  // register events submitter to be executed when events cache is full
+  events.setOnFullQueueCb(() => {
+    if (submitter.isRunning()) {
+      log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+      submitter.execute();
+    }
+    // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
+    // Data will be sent when submitter is resumed.
+  });
+
+  return submitter;
+}

package/src/sync/submitters/{impressionCountsSyncTask.ts → impressionCountsSubmitter.ts}

@@ -1,9 +1,6 @@
-import { ISyncTask, ITimeTracker } from '../types';
-import { IPostTestImpressionsCount } from '../../services/types';
-import { IImpressionCountsCacheSync } from '../../storages/types';
-import { submitterSyncTaskFactory } from './submitterSyncTask';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { submitterFactory } from './submitter';
 import { ImpressionCountsPayload } from './types';
-import { ILogger } from '../../logger/types';
 
 /**
  * Converts `impressionCounts` data from cache into request payload.
@@ -32,15 +29,18 @@ export function fromImpressionCountsCollector(impressionsCount: Record<string, n
 const IMPRESSIONS_COUNT_RATE = 1800000; // 30 minutes
 
 /**
- * Sync task that periodically posts impression counts
+ * Submitter that periodically posts impression counts
  */
-export function impressionCountsSyncTaskFactory(
-  log: ILogger,
-  postTestImpressionsCount: IPostTestImpressionsCount,
-  impressionCountsCache: IImpressionCountsCacheSync,
-  latencyTracker?: ITimeTracker
-): ISyncTask {
-
-  // retry impressions counts only once.
-  return submitterSyncTaskFactory(log, postTestImpressionsCount, impressionCountsCache, IMPRESSIONS_COUNT_RATE, 'impression counts', latencyTracker, fromImpressionCountsCollector, 1);
+export function impressionCountsSubmitterFactory(params: ISdkFactoryContextSync) {
+
+  const {
+    settings: { log },
+    splitApi: { postTestImpressionsCount },
+    storage: { impressionCounts }
+  } = params;
+
+  if (impressionCounts) {
+    // retry impressions counts only once.
+    return submitterFactory(log, postTestImpressionsCount, impressionCounts, IMPRESSIONS_COUNT_RATE, 'impression counts', fromImpressionCountsCollector, 1);
+  }
 }

package/src/sync/submitters/{impressionsSyncTask.ts → impressionsSubmitter.ts}

@@ -1,12 +1,9 @@
 import { groupBy, forOwn } from '../../utils/lang';
-import { ISyncTask, ITimeTracker } from '../types';
-import { IPostTestImpressionsBulk } from '../../services/types';
-import { IImpressionsCacheSync } from '../../storages/types';
 import { ImpressionDTO } from '../../types';
-import { submitterSyncTaskFactory } from './submitterSyncTask';
+import { submitterFactory } from './submitter';
 import { ImpressionsPayload } from './types';
-import { ILogger } from '../../logger/types';
 import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
 const DATA_NAME = 'impressions';
 
@@ -41,22 +38,21 @@ export function fromImpressionsCollector(sendLabels: boolean, data: ImpressionDT
 }
 
 /**
- * Sync task that periodically posts impressions data
+ * Submitter that periodically posts impressions data
  */
-export function impressionsSyncTaskFactory(
-  log: ILogger,
-  postTestImpressionsBulk: IPostTestImpressionsBulk,
-  impressionsCache: IImpressionsCacheSync,
-  impressionsRefreshRate: number,
-  sendLabels = false,
-  latencyTracker?: ITimeTracker,
-): ISyncTask {
+export function impressionsSubmitterFactory(params: ISdkFactoryContextSync) {
+
+  const {
+    settings: { log, scheduler: { impressionsRefreshRate }, core: { labelsEnabled } },
+    splitApi: { postTestImpressionsBulk },
+    storage: { impressions }
+  } = params;
 
   // retry impressions only once.
-  const syncTask = submitterSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, DATA_NAME, latencyTracker, fromImpressionsCollector.bind(undefined, sendLabels), 1);
+  const syncTask = submitterFactory(log, postTestImpressionsBulk, impressions, impressionsRefreshRate, DATA_NAME, fromImpressionsCollector.bind(undefined, labelsEnabled), 1);
 
   // register impressions submitter to be executed when impressions cache is full
-  impressionsCache.setOnFullQueueCb(() => {
+  impressions.setOnFullQueueCb(() => {
     if (syncTask.isRunning()) {
       log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
       syncTask.execute();

package/src/sync/submitters/{submitterSyncTask.ts → submitter.ts}

@@ -1,20 +1,19 @@
 import { syncTaskFactory } from '../syncTask';
-import { ISyncTask, ITimeTracker } from '../types';
+import { ISyncTask } from '../types';
 import { IRecorderCacheProducerSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { SUBMITTERS_PUSH, SUBMITTERS_PUSH_FAILS, SUBMITTERS_PUSH_RETRY } from '../../logger/constants';
 import { IResponse } from '../../services/types';
 
 /**
- * Base function to create submitter sync tasks, such as ImpressionsSyncTask and EventsSyncTask
+ * Base function to create submitters, such as ImpressionsSubmitter and EventsSubmitter
  */
-export function submitterSyncTaskFactory<TState extends { length?: number }>(
+export function submitterFactory<TState>(
   log: ILogger,
   postClient: (body: string) => Promise<IResponse>,
   sourceCache: IRecorderCacheProducerSync<TState>,
   postRate: number,
   dataName: string,
-  latencyTracker?: ITimeTracker,
   fromCacheToPayload?: (cacheData: TState) => any,
   maxRetries: number = 0,
   debugLogs?: boolean
@@ -26,33 +25,52 @@ export function submitterSyncTaskFactory<TState extends { length?: number }>(
     if (sourceCache.isEmpty()) return Promise.resolve();
 
     const data = sourceCache.state();
-
-    const dataCount: number | '' = typeof data.length === 'number' ? data.length : '';
-    log[debugLogs ? 'debug' : 'info'](SUBMITTERS_PUSH, [dataCount, dataName]);
-    const latencyTrackerStop = latencyTracker && latencyTracker.start();
+    // @ts-ignore
+    const dataCountMessage = typeof data.length === 'number' ? `${data.length} ${dataName}` : dataName;
+    log[debugLogs ? 'debug' : 'info'](SUBMITTERS_PUSH, [dataCountMessage]);
 
     const jsonPayload = JSON.stringify(fromCacheToPayload ? fromCacheToPayload(data) : data);
     if (!maxRetries) sourceCache.clear();
 
-    const postPromise = postClient(jsonPayload).then(() => {
+    return postClient(jsonPayload).then(() => {
       retries = 0;
       sourceCache.clear(); // we clear the queue if request successes.
     }).catch(err => {
       if (!maxRetries) {
-        log.warn(SUBMITTERS_PUSH_FAILS, [dataCount, dataName, err]);
+        log.warn(SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
       } else if (retries === maxRetries) {
         retries = 0;
         sourceCache.clear(); // we clear the queue if request fails after retries.
-        log.warn(SUBMITTERS_PUSH_FAILS, [dataCount, dataName, err]);
+        log.warn(SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
       } else {
         retries++;
-        log.warn(SUBMITTERS_PUSH_RETRY, [dataCount, dataName, err]);
+        log.warn(SUBMITTERS_PUSH_RETRY, [dataCountMessage, err]);
       }
     });
-
-    // if latencyTracker provided, attach stop callback to postEventsPromise
-    return latencyTrackerStop ? postPromise.then(latencyTrackerStop).catch(latencyTrackerStop) : postPromise;
   }
 
   return syncTaskFactory(log, postData, postRate, dataName + ' submitter');
 }
+
+/**
+ * Decorates a provided submitter with a first execution window
+ */
+export function firstPushWindowDecorator(submitter: ISyncTask, firstPushWindow: number) {
+  let running = false;
+  let stopEventPublisherTimeout: ReturnType<typeof setTimeout>;
+  const originalStart = submitter.start;
+  submitter.start = () => {
+    running = true;
+    stopEventPublisherTimeout = setTimeout(originalStart, firstPushWindow);
+  };
+  const originalStop = submitter.stop;
+  submitter.stop = () => {
+    running = false;
+    clearTimeout(stopEventPublisherTimeout);
+    originalStop();
+  };
+  submitter.isRunning = () => {
+    return running;
+  };
+  return submitter;
+}

package/src/sync/submitters/submitterManager.ts

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

package/src/sync/submitters/telemetrySubmitter.ts

@@ -0,0 +1,143 @@
+import { ISegmentsCacheSync, ISplitsCacheSync, ITelemetryCacheSync } from '../../storages/types';
+import { submitterFactory, firstPushWindowDecorator } from './submitter';
+import { TelemetryUsageStatsPayload, TelemetryConfigStatsPayload } from './types';
+import { QUEUED, DEDUPED, DROPPED, CONSUMER_MODE, CONSUMER_ENUM, STANDALONE_MODE, CONSUMER_PARTIAL_MODE, STANDALONE_ENUM, CONSUMER_PARTIAL_ENUM, OPTIMIZED, DEBUG, DEBUG_ENUM, OPTIMIZED_ENUM } from '../../utils/constants';
+import { SDK_READY, SDK_READY_FROM_CACHE } from '../../readiness/constants';
+import { ISettings } from '../../types';
+import { base } from '../../utils/settingsValidation';
+import { usedKeysMap } from '../../utils/inputValidation/apiKey';
+import { timer } from '../../utils/timeTracker/timer';
+import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+
+/**
+ * Converts data from telemetry cache into /metrics/usage request payload.
+ */
+export function telemetryCacheStatsAdapter(telemetry: ITelemetryCacheSync, splits: ISplitsCacheSync, segments: ISegmentsCacheSync) {
+  return {
+    isEmpty() { return false; }, // There is always data in telemetry cache
+    clear() { }, //  No-op
+
+    // @TODO consider moving inside telemetry cache for code size reduction
+    state(): TelemetryUsageStatsPayload {
+      return {
+        lS: telemetry.getLastSynchronization(),
+        mL: telemetry.popLatencies(),
+        mE: telemetry.popExceptions(),
+        hE: telemetry.popHttpErrors(),
+        hL: telemetry.popHttpLatencies(),
+        tR: telemetry.popTokenRefreshes(),
+        aR: telemetry.popAuthRejections(),
+        iQ: telemetry.getImpressionStats(QUEUED),
+        iDe: telemetry.getImpressionStats(DEDUPED),
+        iDr: telemetry.getImpressionStats(DROPPED),
+        spC: splits.getSplitNames().length,
+        seC: segments.getRegisteredSegments().length,
+        skC: segments.getKeysCount(),
+        sL: telemetry.getSessionLength(),
+        eQ: telemetry.getEventStats(QUEUED),
+        eD: telemetry.getEventStats(DROPPED),
+        sE: telemetry.popStreamingEvents(),
+        t: telemetry.popTags(),
+      };
+    }
+  };
+}
+
+const OPERATION_MODE_MAP = {
+  [STANDALONE_MODE]: STANDALONE_ENUM,
+  [CONSUMER_MODE]: CONSUMER_ENUM,
+  [CONSUMER_PARTIAL_MODE]: CONSUMER_PARTIAL_ENUM
+} as Record<ISettings['mode'], (0 | 1 | 2)>;
+
+const IMPRESSIONS_MODE_MAP = {
+  [OPTIMIZED]: OPTIMIZED_ENUM,
+  [DEBUG]: DEBUG_ENUM
+} as Record<ISettings['sync']['impressionsMode'], (0 | 1)>;
+
+function getActiveFactories() {
+  return Object.keys(usedKeysMap).length;
+}
+
+function getRedundantActiveFactories() {
+  return Object.keys(usedKeysMap).reduce((acum, apiKey) => {
+    return acum + usedKeysMap[apiKey] - 1;
+  }, 0);
+}
+
+/**
+ * Converts data from telemetry cache and settings into /metrics/config request payload.
+ */
+export function telemetryCacheConfigAdapter(telemetry: ITelemetryCacheSync, settings: ISettings) {
+  return {
+    isEmpty() { return false; },
+    clear() { },
+
+    state(): TelemetryConfigStatsPayload {
+      const { urls, scheduler } = settings;
+
+      return {
+        oM: OPERATION_MODE_MAP[settings.mode], // @ts-ignore lower case of storage type
+        st: settings.storage.type.toLowerCase(),
+        sE: settings.streamingEnabled,
+        rR: {
+          sp: scheduler.featuresRefreshRate,
+          se: scheduler.segmentsRefreshRate,
+          im: scheduler.impressionsRefreshRate,
+          ev: scheduler.eventsPushRate,
+          te: scheduler.telemetryRefreshRate,
+        }, // refreshRates
+        uO: {
+          s: urls.sdk !== base.urls.sdk,
+          e: urls.events !== base.urls.events,
+          a: urls.auth !== base.urls.auth,
+          st: urls.streaming !== base.urls.streaming,
+          t: urls.telemetry !== base.urls.telemetry,
+        }, // urlOverrides
+        iQ: scheduler.impressionsQueueSize,
+        eQ: scheduler.eventsQueueSize,
+        iM: IMPRESSIONS_MODE_MAP[settings.sync.impressionsMode],
+        iL: settings.impressionListener ? true : false,
+        hP: false, // @TODO proxy not supported
+        aF: getActiveFactories(),
+        rF: getRedundantActiveFactories(),
+        tR: telemetry.getTimeUntilReady() as number,
+        tC: telemetry.getTimeUntilReadyFromCache(),
+        nR: telemetry.getNonReadyUsage(),
+        t: telemetry.popTags(),
+        i: settings.integrations && settings.integrations.map(int => int.type),
+      };
+    }
+  };
+}
+
+/**
+ * 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 { settings, settings: { log, scheduler: { telemetryRefreshRate } }, splitApi, platform: { now }, readiness } = params;
+  const startTime = timer(now || Date.now);
+
+  const submitter = firstPushWindowDecorator(
+    submitterFactory(log, splitApi.postMetricsUsage, telemetryCacheStatsAdapter(telemetry, splits, segments), telemetryRefreshRate, 'telemetry stats', undefined, 0, true),
+    telemetryRefreshRate
+  );
+
+  readiness.gate.once(SDK_READY_FROM_CACHE, () => {
+    telemetry.recordTimeUntilReadyFromCache(startTime());
+  });
+
+  readiness.gate.once(SDK_READY, () => {
+    telemetry.recordTimeUntilReady(startTime());
+
+    // Post config data when the SDK is ready and if the telemetry submitter was started
+    if (submitter.isRunning()) {
+      const postMetricsConfigTask = submitterFactory(log, splitApi.postMetricsConfig, telemetryCacheConfigAdapter(telemetry, settings), 0, 'telemetry config', undefined, 0, true);
+      postMetricsConfigTask.execute();
+    }
+  });
+
+  return submitter;
+}

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
+}