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

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -0,0 +1,161 @@
+import { findLatencyIndex } from '../findLatencyIndex';
+var MAX_STREAMING_EVENTS = 20;
+var MAX_TAGS = 10;
+function newBuckets() {
+    // MAX_LATENCY_BUCKET_COUNT (length) is 23;
+    return [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+}
+var ACCEPTANCE_RANGE = 0.001;
+/**
+ * Used on client-side. 0.1% of instances will track telemetry
+ */
+export function shouldRecordTelemetry() {
+    return Math.random() <= ACCEPTANCE_RANGE;
+}
+var TelemetryCacheInMemory = /** @class */ (function () {
+    function TelemetryCacheInMemory() {
+        this.notReadyUsage = 0;
+        this.impressionStats = [0, 0, 0];
+        this.eventStats = [0, 0];
+        // @ts-expect-error
+        this.lastSync = {};
+        // @ts-expect-error
+        this.httpErrors = {};
+        // @ts-expect-error
+        this.httpLatencies = {};
+        this.authRejections = 0;
+        this.tokenRefreshes = 0;
+        this.streamingEvents = [];
+        this.tags = [];
+        // @ts-expect-error
+        this.exceptions = {};
+        // @ts-expect-error
+        this.latencies = {};
+    }
+    TelemetryCacheInMemory.prototype.getTimeUntilReady = function () {
+        return this.timeUntilReady;
+    };
+    TelemetryCacheInMemory.prototype.recordTimeUntilReady = function (ms) {
+        this.timeUntilReady = ms;
+    };
+    TelemetryCacheInMemory.prototype.getTimeUntilReadyFromCache = function () {
+        return this.timeUntilReadyFromCache;
+    };
+    TelemetryCacheInMemory.prototype.recordTimeUntilReadyFromCache = function (ms) {
+        this.timeUntilReadyFromCache = ms;
+    };
+    TelemetryCacheInMemory.prototype.getNonReadyUsage = function () {
+        return this.notReadyUsage;
+    };
+    TelemetryCacheInMemory.prototype.recordNonReadyUsage = function () {
+        this.notReadyUsage++;
+    };
+    TelemetryCacheInMemory.prototype.getImpressionStats = function (type) {
+        return this.impressionStats[type];
+    };
+    TelemetryCacheInMemory.prototype.recordImpressionStats = function (type, count) {
+        this.impressionStats[type] += count;
+    };
+    TelemetryCacheInMemory.prototype.getEventStats = function (type) {
+        return this.eventStats[type];
+    };
+    TelemetryCacheInMemory.prototype.recordEventStats = function (type, count) {
+        this.eventStats[type] += count;
+    };
+    TelemetryCacheInMemory.prototype.getLastSynchronization = function () {
+        return this.lastSync;
+    };
+    TelemetryCacheInMemory.prototype.recordSuccessfulSync = function (resource, timeMs) {
+        this.lastSync[resource] = timeMs;
+    };
+    TelemetryCacheInMemory.prototype.popHttpErrors = function () {
+        var result = this.httpErrors; // @ts-expect-error
+        this.httpErrors = {};
+        return result;
+    };
+    TelemetryCacheInMemory.prototype.recordHttpError = function (resource, status) {
+        if (!this.httpErrors[resource])
+            this.httpErrors[resource] = {};
+        if (!this.httpErrors[resource][status]) {
+            this.httpErrors[resource][status] = 1;
+        }
+        else {
+            this.httpErrors[resource][status]++;
+        }
+    };
+    TelemetryCacheInMemory.prototype.popHttpLatencies = function () {
+        var result = this.httpLatencies; // @ts-expect-error
+        this.httpLatencies = {};
+        return result;
+    };
+    TelemetryCacheInMemory.prototype.recordHttpLatency = function (resource, latencyMs) {
+        if (!this.httpLatencies[resource]) {
+            this.httpLatencies[resource] = newBuckets();
+        }
+        this.httpLatencies[resource][findLatencyIndex(latencyMs)]++;
+    };
+    TelemetryCacheInMemory.prototype.popAuthRejections = function () {
+        var result = this.authRejections;
+        this.authRejections = 0;
+        return result;
+    };
+    TelemetryCacheInMemory.prototype.recordAuthRejections = function () {
+        this.authRejections++;
+    };
+    TelemetryCacheInMemory.prototype.popTokenRefreshes = function () {
+        var result = this.tokenRefreshes;
+        this.tokenRefreshes = 0;
+        return result;
+    };
+    TelemetryCacheInMemory.prototype.recordTokenRefreshes = function () {
+        this.tokenRefreshes++;
+    };
+    TelemetryCacheInMemory.prototype.popStreamingEvents = function () {
+        return this.streamingEvents.splice(0);
+    };
+    TelemetryCacheInMemory.prototype.recordStreamingEvents = function (streamingEvent) {
+        if (this.streamingEvents.length < MAX_STREAMING_EVENTS) {
+            this.streamingEvents.push(streamingEvent);
+        }
+    };
+    TelemetryCacheInMemory.prototype.popTags = function () {
+        return this.tags.splice(0);
+    };
+    TelemetryCacheInMemory.prototype.addTag = function (tag) {
+        if (this.tags.length < MAX_TAGS) {
+            this.tags.push(tag);
+        }
+    };
+    TelemetryCacheInMemory.prototype.getSessionLength = function () {
+        return this.sessionLength;
+    };
+    TelemetryCacheInMemory.prototype.recordSessionLength = function (ms) {
+        this.sessionLength = ms;
+    };
+    TelemetryCacheInMemory.prototype.popExceptions = function () {
+        var result = this.exceptions; // @ts-expect-error
+        this.exceptions = {};
+        return result;
+    };
+    TelemetryCacheInMemory.prototype.recordException = function (method) {
+        if (!this.exceptions[method]) {
+            this.exceptions[method] = 1;
+        }
+        else {
+            this.exceptions[method]++;
+        }
+    };
+    TelemetryCacheInMemory.prototype.popLatencies = function () {
+        var result = this.latencies; // @ts-expect-error
+        this.latencies = {};
+        return result;
+    };
+    TelemetryCacheInMemory.prototype.recordLatency = function (method, latencyMs) {
+        if (!this.latencies[method]) {
+            this.latencies[method] = newBuckets();
+        }
+        this.latencies[method][findLatencyIndex(latencyMs)]++;
+    };
+    return TelemetryCacheInMemory;
+}());
+export { TelemetryCacheInMemory };

package/esm/storages/inRedis/TelemetryCacheInRedis.js

@@ -0,0 +1,26 @@
+import { findLatencyIndex } from '../findLatencyIndex';
+var TelemetryCacheInRedis = /** @class */ (function () {
+    /**
+     * Create a Telemetry cache that uses Redis as storage.
+     * @param log  Logger instance.
+     * @param keys  Key builder.
+     * @param redis  Redis client.
+     */
+    function TelemetryCacheInRedis(log, keys, redis) {
+        this.log = log;
+        this.keys = keys;
+        this.redis = redis;
+    }
+    TelemetryCacheInRedis.prototype.recordLatency = function (method, latencyMs) {
+        var _a = this.keys.buildLatencyKey(method, findLatencyIndex(latencyMs)).split('::'), key = _a[0], field = _a[1];
+        return this.redis.hincrby(key, field, 1)
+            .catch(function () { });
+    };
+    TelemetryCacheInRedis.prototype.recordException = function (method) {
+        var _a = this.keys.buildExceptionKey(method).split('::'), key = _a[0], field = _a[1];
+        return this.redis.hincrby(key, field, 1)
+            .catch(function () { });
+    };
+    return TelemetryCacheInRedis;
+}());
+export { TelemetryCacheInRedis };

package/esm/storages/inRedis/index.js

@@ -5,9 +5,8 @@ import { SplitsCacheInRedis } from './SplitsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
-import { LatenciesCacheInRedis } from './LatenciesCacheInRedis';
-import { CountsCacheInRedis } from './CountsCacheInRedis';
 import { STORAGE_REDIS } from '../../utils/constants';
+import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 /**
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
@@ -28,8 +27,7 @@ export function InRedisStorage(options) {
             segments: new SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
             events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
-            latencies: new LatenciesCacheInRedis(keys, redisClient),
-            counts: new CountsCacheInRedis(keys, redisClient),
+            telemetry: new TelemetryCacheInRedis(log, keys, redisClient),
             // When using REDIS we should:
             // 1- Disconnect from the storage
             destroy: function () {

package/esm/storages/pluggable/TelemetryCachePluggable.js

@@ -0,0 +1,24 @@
+import { findLatencyIndex } from '../findLatencyIndex';
+var TelemetryCachePluggable = /** @class */ (function () {
+    /**
+     * Create a Telemetry cache that uses a storage wrapper.
+     * @param log  Logger instance.
+     * @param keys  Key builder.
+     * @param wrapper  Adapted wrapper storage.
+     */
+    function TelemetryCachePluggable(log, keys, wrapper) {
+        this.log = log;
+        this.keys = keys;
+        this.wrapper = wrapper;
+    }
+    TelemetryCachePluggable.prototype.recordLatency = function (method, latencyMs) {
+        return this.wrapper.incr(this.keys.buildLatencyKey(method, findLatencyIndex(latencyMs)))
+            .catch(function () { });
+    };
+    TelemetryCachePluggable.prototype.recordException = function (method) {
+        return this.wrapper.incr(this.keys.buildExceptionKey(method))
+            .catch(function () { });
+    };
+    return TelemetryCachePluggable;
+}());
+export { TelemetryCachePluggable };

package/esm/storages/pluggable/index.js

@@ -63,7 +63,8 @@ export function PluggableStorage(options) {
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
             impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
-            // @TODO add telemetry cache when required
+            // @TODO Not using TelemetryCachePluggable yet, because it is not supported by the Split Synchronizer
+            // telemetry: isPartialConsumer ? new TelemetryCacheInMemory() : new TelemetryCachePluggable(log, keys, wrapper),
             // Disconnect the underlying storage
             destroy: function () {
                 return wrapper.disconnect();

package/esm/sync/polling/pollingManagerCS.js

@@ -11,7 +11,7 @@ import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger
 export function pollingManagerCSFactory(params) {
     var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
-    var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
+    var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
     // Map of matching keys to their corresponding MySegmentsSyncTask.
     var mySegmentsSyncTasks = {};
     var matchingKey = getMatching(settings.core.key);

package/esm/sync/polling/syncTasks/splitsSyncTask.js

@@ -4,6 +4,6 @@ import { splitChangesUpdaterFactory } from '../updaters/splitChangesUpdater';
 /**
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
-export function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings) {
-    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges), storage.splits, storage.segments, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
+export function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
+    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges), storage.splits, storage.segments, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
 }

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -15,9 +15,6 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
         if (startingUp)
             promise = timeout(requestTimeoutBeforeReady, promise);
         return promise;
-        // @TODO telemetry
-        // NOTE: We only collect metrics on startup.
-        // mySegmentsPromise = tracker.start(tracker.TaskNames.MY_SEGMENTS_FETCH, startingUp ? metricCollectors : false, mySegmentsPromise);
     }
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {

package/esm/sync/polling/updaters/segmentChangesUpdater.js

@@ -15,13 +15,6 @@ import { thenable } from '../../../utils/promise/thenable';
  */
 export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness) {
     var readyOnAlreadyExistentState = true;
-    /** telemetry decorator for `segmentChangesFetcher` promise  */
-    function _promiseDecorator(promise) {
-        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.
@@ -47,7 +40,7 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                     // 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) {
                         var changeNumber = -1;
                         var results = [];
                         changes.forEach(function (x) {

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -64,18 +64,15 @@ export function computeSplitsMutation(entries) {
  * @param requestTimeoutBeforeReady  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
  * @param retriesOnFailureBeforeReady  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady) {
+export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
     if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }
     if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }
     var startingUp = true;
-    /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
+    /** timeout decorator for `splitChangesFetcher` promise  */
     function _promiseDecorator(promise) {
         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);
     }
     /**
      * SplitChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
@@ -109,7 +106,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 ]).then(function () {
                     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(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                             .then(function (emitSplitsArrivedEvent) {
                             // emit SDK events

package/esm/sync/streaming/SSEHandler/NotificationKeeper.js

@@ -1,12 +1,14 @@
+import { CONNECTION_ESTABLISHED, DISABLED, ENABLED, OCCUPANCY_PRI, OCCUPANCY_SEC, PAUSED, STREAMING_STATUS } from '../../../utils/constants';
 import { ControlType, PUSH_SUBSYSTEM_UP, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN } from '../constants';
 var CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
+var STREAMING_EVENT_TYPES = [OCCUPANCY_PRI, OCCUPANCY_SEC];
 /**
  * Factory of notification keeper, which process OCCUPANCY and CONTROL notifications and emits the corresponding push events.
  *
  * @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) {
+export function notificationKeeperFactory(pushEmitter, telemetryTracker) {
     var channels = CONTROL_CHANNEL_REGEXS.map(function (regex) { return ({
         regex: regex,
         hasPublishers: true,
@@ -22,6 +24,7 @@ export function notificationKeeperFactory(pushEmitter) {
     }
     return {
         handleOpen: function () {
+            telemetryTracker.streamingEvent(CONNECTION_ESTABLISHED);
             pushEmitter.emit(PUSH_SUBSYSTEM_UP);
         },
         isStreamingUp: function () {
@@ -31,6 +34,7 @@ export function notificationKeeperFactory(pushEmitter) {
             for (var i = 0; i < channels.length; i++) {
                 var 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;
@@ -65,13 +69,16 @@ export function notificationKeeperFactory(pushEmitter) {
                     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/esm/sync/streaming/SSEHandler/index.js

@@ -2,27 +2,33 @@ import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
 import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
-function isRetryableError(error) {
-    if (error.parsedData && error.parsedData.code) {
-        var 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';
 /**
  * Factory for SSEHandler, which processes SSEClient messages and emits the corresponding push events.
  *
  * @param log factory logger
  * @param pushEmitter emitter for events related to streaming support
  */
-export function SSEHandlerFactory(log, pushEmitter) {
-    var notificationKeeper = notificationKeeperFactory(pushEmitter);
+export function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
+    var notificationKeeper = notificationKeeperFactory(pushEmitter, telemetryTracker);
+    function isRetryableError(error) {
+        if (error.parsedData && error.parsedData.code) {
+            // Ably error
+            var 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: function () {
             notificationKeeper.handleOpen();

package/esm/sync/streaming/pushManager.js

@@ -14,13 +14,14 @@ import { UpdateStrategy } from './SSEHandler/types';
 import { isInBitmap, parseBitmap, parseKeyList } from './mySegmentsV2utils';
 import { _Set } from '../../utils/lang/sets';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
+import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 /**
  * PushManager factory:
  * - for server-side if key is not provided in settings.
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
 export function pushManagerFactory(params, pollingManager) {
-    var settings = params.settings, storage = params.storage, splitApi = params.splitApi, readiness = params.readiness, platform = params.platform;
+    var settings = params.settings, storage = params.storage, splitApi = params.splitApi, readiness = params.readiness, platform = params.platform, telemetryTracker = params.telemetryTracker;
     // `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.
     var userKey = settings.core.key ? getMatching(settings.core.key) : undefined;
@@ -37,7 +38,7 @@ export function pushManagerFactory(params, pollingManager) {
     var authenticate = authenticateFactory(splitApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
-    var sseHandler = SSEHandlerFactory(log, pushEmitter);
+    var sseHandler = SSEHandlerFactory(log, pushEmitter, telemetryTracker);
     sseClient.setEventHandler(sseHandler);
     // init workers
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
@@ -80,6 +81,7 @@ export function pushManagerFactory(params, pollingManager) {
                 return;
             sseClient.open(authData);
         }, connDelay * 1000);
+        telemetryTracker.streamingEvent(TOKEN_REFRESH, decodedToken.exp);
     }
     function connectPush() {
         // Guard condition in case `stop/disconnectPush` has been called (e.g., calling SDK destroy, or app signal close/background)
@@ -110,6 +112,7 @@ export function pushManagerFactory(params, pollingManager) {
             log.error(ERROR_STREAMING_AUTH, [error.message]);
             // 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;
             }
@@ -150,14 +153,14 @@ export function pushManagerFactory(params, pollingManager) {
         connectPushRetryBackoff.reset();
         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;
         // Note: `stopWorkers` is been called twice, but it is not harmful
         disconnectPush();
         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() {
         // SSE connection is closed to avoid repeated errors due to retries
         sseClient.close();

package/esm/sync/submitters/eventsSubmitter.js

@@ -0,0 +1,24 @@
+import { submitterFactory, firstPushWindowDecorator } from './submitter';
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+var DATA_NAME = 'events';
+/**
+ * Submitter that periodically posts tracked events
+ */
+export function eventsSubmitterFactory(params) {
+    var _a = params.settings, log = _a.log, eventsPushRate = _a.scheduler.eventsPushRate, eventsFirstPushWindow = _a.startup.eventsFirstPushWindow, postEventsBulk = params.splitApi.postEventsBulk, events = params.storage.events;
+    // don't retry events.
+    var 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(function () {
+        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/esm/sync/submitters/{impressionCountsSyncTask.js → impressionCountsSubmitter.js}

@@ -1,4 +1,4 @@
-import { submitterSyncTaskFactory } from './submitterSyncTask';
+import { submitterFactory } from './submitter';
 /**
  * Converts `impressionCounts` data from cache into request payload.
  */
@@ -22,9 +22,12 @@ export function fromImpressionCountsCollector(impressionsCount) {
 }
 var IMPRESSIONS_COUNT_RATE = 1800000; // 30 minutes
 /**
- * Sync task that periodically posts impression counts
+ * Submitter that periodically posts impression counts
  */
-export function impressionCountsSyncTaskFactory(log, postTestImpressionsCount, impressionCountsCache, latencyTracker) {
-    // retry impressions counts only once.
-    return submitterSyncTaskFactory(log, postTestImpressionsCount, impressionCountsCache, IMPRESSIONS_COUNT_RATE, 'impression counts', latencyTracker, fromImpressionCountsCollector, 1);
+export function impressionCountsSubmitterFactory(params) {
+    var log = params.settings.log, postTestImpressionsCount = params.splitApi.postTestImpressionsCount, impressionCounts = params.storage.impressionCounts;
+    if (impressionCounts) {
+        // retry impressions counts only once.
+        return submitterFactory(log, postTestImpressionsCount, impressionCounts, IMPRESSIONS_COUNT_RATE, 'impression counts', fromImpressionCountsCollector, 1);
+    }
 }

package/esm/sync/submitters/{impressionsSyncTask.js → impressionsSubmitter.js}

@@ -1,5 +1,5 @@
 import { groupBy, forOwn } from '../../utils/lang';
-import { submitterSyncTaskFactory } from './submitterSyncTask';
+import { submitterFactory } from './submitter';
 import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
 var DATA_NAME = 'impressions';
 /**
@@ -29,14 +29,14 @@ export function fromImpressionsCollector(sendLabels, data) {
     return dto;
 }
 /**
- * Sync task that periodically posts impressions data
+ * Submitter that periodically posts impressions data
  */
-export function impressionsSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, sendLabels, latencyTracker) {
-    if (sendLabels === void 0) { sendLabels = false; }
+export function impressionsSubmitterFactory(params) {
+    var _a = params.settings, log = _a.log, impressionsRefreshRate = _a.scheduler.impressionsRefreshRate, labelsEnabled = _a.core.labelsEnabled, postTestImpressionsBulk = params.splitApi.postTestImpressionsBulk, impressions = params.storage.impressions;
     // retry impressions only once.
-    var syncTask = submitterSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, DATA_NAME, latencyTracker, fromImpressionsCollector.bind(undefined, sendLabels), 1);
+    var 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(function () {
+    impressions.setOnFullQueueCb(function () {
         if (syncTask.isRunning()) {
             log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
             syncTask.execute();

package/esm/sync/submitters/submitter.js

@@ -0,0 +1,61 @@
+import { syncTaskFactory } from '../syncTask';
+import { SUBMITTERS_PUSH, SUBMITTERS_PUSH_FAILS, SUBMITTERS_PUSH_RETRY } from '../../logger/constants';
+/**
+ * Base function to create submitters, such as ImpressionsSubmitter and EventsSubmitter
+ */
+export function submitterFactory(log, postClient, sourceCache, postRate, dataName, fromCacheToPayload, maxRetries, debugLogs // true for telemetry submitters
+) {
+    if (maxRetries === void 0) { maxRetries = 0; }
+    var retries = 0;
+    function postData() {
+        if (sourceCache.isEmpty())
+            return Promise.resolve();
+        var data = sourceCache.state();
+        // @ts-ignore
+        var dataCountMessage = typeof data.length === 'number' ? data.length + " " + dataName : dataName;
+        log[debugLogs ? 'debug' : 'info'](SUBMITTERS_PUSH, [dataCountMessage]);
+        var jsonPayload = JSON.stringify(fromCacheToPayload ? fromCacheToPayload(data) : data);
+        if (!maxRetries)
+            sourceCache.clear();
+        return postClient(jsonPayload).then(function () {
+            retries = 0;
+            sourceCache.clear(); // we clear the queue if request successes.
+        }).catch(function (err) {
+            if (!maxRetries) {
+                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[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_FAILS, [dataCountMessage, err]);
+            }
+            else {
+                retries++;
+                log[debugLogs ? 'debug' : 'warn'](SUBMITTERS_PUSH_RETRY, [dataCountMessage, err]);
+            }
+        });
+    }
+    return syncTaskFactory(log, postData, postRate, dataName + ' submitter');
+}
+/**
+ * Decorates a provided submitter with a first execution window
+ */
+export function firstPushWindowDecorator(submitter, firstPushWindow) {
+    var running = false;
+    var stopEventPublisherTimeout;
+    var originalStart = submitter.start;
+    submitter.start = function () {
+        running = true;
+        stopEventPublisherTimeout = setTimeout(originalStart, firstPushWindow);
+    };
+    var originalStop = submitter.stop;
+    submitter.stop = function () {
+        running = false;
+        clearTimeout(stopEventPublisherTimeout);
+        originalStop();
+    };
+    submitter.isRunning = function () {
+        return running;
+    };
+    return submitter;
+}