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

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -1,7 +1,7 @@
 import { ISegmentChangesFetcher } from '../fetchers/types';
 import { ISegmentsCacheBase } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
-import { ISegmentChangesResponse, MaybeThenable } from '../../../dtos/types';
+import { MaybeThenable } from '../../../dtos/types';
 import { findIndex } from '../../../utils/lang';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
@@ -30,14 +30,6 @@ export function segmentChangesUpdaterFactory(
 
   let readyOnAlreadyExistentState = true;
 
-  /** telemetry decorator for `segmentChangesFetcher` promise  */
-  function _promiseDecorator(promise: Promise<ISegmentChangesResponse[]>) {
-    return promise;
-    // @TODO handle telemetry?
-    // const collectMetrics = startingUp || isNode; // If we are on the browser, only collect this metric for first fetch. On node do it always.
-    // splitsPromise = tracker.start(tracker.TaskNames.SPLITS_FETCH, collectMetrics ? metricCollectors : false, splitsPromise);
-  }
-
   /**
    * Segments updater returns a promise that resolves with a `false` boolean value if it fails at least to fetch a segment or synchronize it with the storage.
    * Thus, a false result doesn't imply that SDK_SEGMENTS_ARRIVED was not emitted.
@@ -67,7 +59,7 @@ export function segmentChangesUpdaterFactory(
           // if fetchOnlyNew flag, avoid processing already fetched segments
           if (fetchOnlyNew && since !== -1) return -1;
 
-          return segmentChangesFetcher(since, segmentName, noCache, _promiseDecorator).then(function (changes) {
+          return segmentChangesFetcher(since, segmentName, noCache).then(function (changes) {
             let changeNumber = -1;
             const results: MaybeThenable<boolean | void>[] = [];
             changes.forEach(x => {

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -93,18 +93,15 @@ export function splitChangesUpdaterFactory(
   splitsEventEmitter?: ISplitsEventEmitter,
   requestTimeoutBeforeReady: number = 0,
   retriesOnFailureBeforeReady: number = 0,
+  isClientSide?: boolean
 ): ISplitChangesUpdater {
 
   let startingUp = true;
 
-  /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
+  /** timeout decorator for `splitChangesFetcher` promise  */
   function _promiseDecorator<T>(promise: Promise<T>) {
     if (startingUp && requestTimeoutBeforeReady) promise = timeout(requestTimeoutBeforeReady, promise);
     return promise;
-
-    // @TODO telemetry
-    // const collectMetrics = startingUp || isNode; // If we are on the browser, only collect this metric for first fetch. On node do it always.
-    // splitsPromise = tracker.start(tracker.TaskNames.SPLITS_FETCH, collectMetrics ? metricCollectors : false, splitsPromise);
   }
 
   /**
@@ -144,7 +141,7 @@ export function splitChangesUpdaterFactory(
 
             if (splitsEventEmitter) {
               // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-              return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && checkAllSegmentsExist(segments)))
+              return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && (isClientSide || checkAllSegmentsExist(segments))))
                 .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                 .then(emitSplitsArrivedEvent => {
                   // emit SDK events

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

@@ -1,7 +1,11 @@
+import { ITelemetryTracker } from '../../../trackers/types';
+import { CONNECTION_ESTABLISHED, DISABLED, ENABLED, OCCUPANCY_PRI, OCCUPANCY_SEC, PAUSED, STREAMING_STATUS } from '../../../utils/constants';
+import { StreamingEventType } from '../../submitters/types';
 import { ControlType, PUSH_SUBSYSTEM_UP, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN } from '../constants';
 import { IPushEventEmitter } from '../types';
 
 const CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
+const STREAMING_EVENT_TYPES: StreamingEventType[] = [OCCUPANCY_PRI, OCCUPANCY_SEC];
 
 /**
  * Factory of notification keeper, which process OCCUPANCY and CONTROL notifications and emits the corresponding push events.
@@ -9,7 +13,7 @@ const CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
  * @param pushEmitter emitter for events related to streaming support
  */
 // @TODO update logic to handle OCCUPANCY for any region and rename according to new spec (e.g.: PUSH_SUBSYSTEM_UP --> PUSH_SUBSYSTEM_UP)
-export function notificationKeeperFactory(pushEmitter: IPushEventEmitter) {
+export function notificationKeeperFactory(pushEmitter: IPushEventEmitter, telemetryTracker: ITelemetryTracker) {
 
   let channels = CONTROL_CHANNEL_REGEXS.map(regex => ({
     regex,
@@ -30,6 +34,7 @@ export function notificationKeeperFactory(pushEmitter: IPushEventEmitter) {
 
   return {
     handleOpen() {
+      telemetryTracker.streamingEvent(CONNECTION_ESTABLISHED);
       pushEmitter.emit(PUSH_SUBSYSTEM_UP);
     },
 
@@ -41,6 +46,8 @@ export function notificationKeeperFactory(pushEmitter: IPushEventEmitter) {
       for (let i = 0; i < channels.length; i++) {
         const c = channels[i];
         if (c.regex.test(channel)) {
+          telemetryTracker.streamingEvent(STREAMING_EVENT_TYPES[i], publishers);
+
           if (timestamp > c.oTime) {
             c.oTime = timestamp;
             c.hasPublishers = publishers !== 0;
@@ -76,11 +83,14 @@ export function notificationKeeperFactory(pushEmitter: IPushEventEmitter) {
           if (timestamp > c.cTime) {
             c.cTime = timestamp;
             if (controlType === ControlType.STREAMING_DISABLED) {
+              telemetryTracker.streamingEvent(STREAMING_STATUS, DISABLED);
               pushEmitter.emit(PUSH_NONRETRYABLE_ERROR);
             } else if (hasPublishers) {
               if (controlType === ControlType.STREAMING_PAUSED && hasResumed) {
+                telemetryTracker.streamingEvent(STREAMING_STATUS, PAUSED);
                 pushEmitter.emit(PUSH_SUBSYSTEM_DOWN);
               } else if (controlType === ControlType.STREAMING_RESUMED && !hasResumed) {
+                telemetryTracker.streamingEvent(STREAMING_STATUS, ENABLED);
                 pushEmitter.emit(PUSH_SUBSYSTEM_UP);
               }
               // nothing to do when hasPublishers === false:

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,23 +1,22 @@
 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
+  debugLogs?: boolean // true for telemetry submitters
 ): ISyncTask<[], void> {
 
   let retries = 0;
@@ -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[debugLogs ? 'debug' : '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[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
       } else {
         retries++;
-        log.warn(SUBMITTERS_PUSH_RETRY, [dataCount, dataName, err]);
+        log[debugLogs ? 'debug' : '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;
+}