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

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryCacheInMemory = exports.shouldRecordTelemetry = void 0;
+var findLatencyIndex_1 = require("../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
+ */
+function shouldRecordTelemetry() {
+    return Math.random() <= ACCEPTANCE_RANGE;
+}
+exports.shouldRecordTelemetry = shouldRecordTelemetry;
+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][(0, findLatencyIndex_1.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][(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
+    };
+    return TelemetryCacheInMemory;
+}());
+exports.TelemetryCacheInMemory = TelemetryCacheInMemory;

package/cjs/storages/inRedis/TelemetryCacheInRedis.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryCacheInRedis = void 0;
+var findLatencyIndex_1 = require("../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, (0, findLatencyIndex_1.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;
+}());
+exports.TelemetryCacheInRedis = TelemetryCacheInRedis;

package/cjs/storages/inRedis/index.js

@@ -8,9 +8,8 @@ var SplitsCacheInRedis_1 = require("./SplitsCacheInRedis");
 var SegmentsCacheInRedis_1 = require("./SegmentsCacheInRedis");
 var ImpressionsCacheInRedis_1 = require("./ImpressionsCacheInRedis");
 var EventsCacheInRedis_1 = require("./EventsCacheInRedis");
-var LatenciesCacheInRedis_1 = require("./LatenciesCacheInRedis");
-var CountsCacheInRedis_1 = require("./CountsCacheInRedis");
 var constants_1 = require("../../utils/constants");
+var TelemetryCacheInRedis_1 = require("./TelemetryCacheInRedis");
 /**
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
@@ -31,8 +30,7 @@ function InRedisStorage(options) {
             segments: new SegmentsCacheInRedis_1.SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis_1.ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
             events: new EventsCacheInRedis_1.EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
-            latencies: new LatenciesCacheInRedis_1.LatenciesCacheInRedis(keys, redisClient),
-            counts: new CountsCacheInRedis_1.CountsCacheInRedis(keys, redisClient),
+            telemetry: new TelemetryCacheInRedis_1.TelemetryCacheInRedis(log, keys, redisClient),
             // When using REDIS we should:
             // 1- Disconnect from the storage
             destroy: function () {

package/cjs/storages/pluggable/TelemetryCachePluggable.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryCachePluggable = void 0;
+var findLatencyIndex_1 = require("../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, (0, findLatencyIndex_1.findLatencyIndex)(latencyMs)))
+            .catch(function () { });
+    };
+    TelemetryCachePluggable.prototype.recordException = function (method) {
+        return this.wrapper.incr(this.keys.buildExceptionKey(method))
+            .catch(function () { });
+    };
+    return TelemetryCachePluggable;
+}());
+exports.TelemetryCachePluggable = TelemetryCachePluggable;

package/cjs/storages/pluggable/index.js

@@ -66,7 +66,8 @@ function PluggableStorage(options) {
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory_1.ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable_1.ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
             impressionCounts: optimize ? new ImpressionCountsCacheInMemory_1.ImpressionCountsCacheInMemory() : undefined,
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory_1.EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable_1.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/cjs/sync/polling/pollingManagerCS.js

@@ -14,7 +14,7 @@ var constants_2 = require("../../logger/constants");
 function pollingManagerCSFactory(params) {
     var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
-    var splitsSyncTask = (0, splitsSyncTask_1.splitsSyncTaskFactory)(splitApi.fetchSplitChanges, storage, readiness, settings);
+    var splitsSyncTask = (0, splitsSyncTask_1.splitsSyncTaskFactory)(splitApi.fetchSplitChanges, storage, readiness, settings, true);
     // Map of matching keys to their corresponding MySegmentsSyncTask.
     var mySegmentsSyncTasks = {};
     var matchingKey = (0, key_1.getMatching)(settings.core.key);

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

@@ -7,7 +7,7 @@ var splitChangesUpdater_1 = require("../updaters/splitChangesUpdater");
 /**
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
-function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, splitChangesUpdater_1.splitChangesUpdaterFactory)(settings.log, (0, splitChangesFetcher_1.splitChangesFetcherFactory)(fetchSplitChanges), storage.splits, storage.segments, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
+function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, splitChangesUpdater_1.splitChangesUpdaterFactory)(settings.log, (0, splitChangesFetcher_1.splitChangesFetcherFactory)(fetchSplitChanges), storage.splits, storage.segments, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
 }
 exports.splitsSyncTaskFactory = splitsSyncTaskFactory;

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

@@ -18,9 +18,6 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegment
         if (startingUp)
             promise = (0, timeout_1.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/cjs/sync/polling/updaters/segmentChangesUpdater.js

@@ -18,13 +18,6 @@ var thenable_1 = require("../../../utils/promise/thenable");
  */
 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.
@@ -50,7 +43,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
                     // 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/cjs/sync/polling/updaters/splitChangesUpdater.js

@@ -69,18 +69,15 @@ exports.computeSplitsMutation = computeSplitsMutation;
  * @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.
  */
-function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady) {
+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 = (0, timeout_1.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.
@@ -114,7 +111,7 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
                 ]).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/cjs/sync/streaming/SSEHandler/NotificationKeeper.js

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.notificationKeeperFactory = void 0;
-var constants_1 = require("../constants");
+var constants_1 = require("../../../utils/constants");
+var constants_2 = require("../constants");
 var CONTROL_CHANNEL_REGEXS = [/control_pri$/, /control_sec$/];
+var STREAMING_EVENT_TYPES = [constants_1.OCCUPANCY_PRI, constants_1.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)
-function notificationKeeperFactory(pushEmitter) {
+function notificationKeeperFactory(pushEmitter, telemetryTracker) {
     var channels = CONTROL_CHANNEL_REGEXS.map(function (regex) { return ({
         regex: regex,
         hasPublishers: true,
@@ -25,7 +27,8 @@ function notificationKeeperFactory(pushEmitter) {
     }
     return {
         handleOpen: function () {
-            pushEmitter.emit(constants_1.PUSH_SUBSYSTEM_UP);
+            telemetryTracker.streamingEvent(constants_1.CONNECTION_ESTABLISHED);
+            pushEmitter.emit(constants_2.PUSH_SUBSYSTEM_UP);
         },
         isStreamingUp: function () {
             return hasResumed && hasPublishers;
@@ -34,16 +37,17 @@ 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;
                         var hasPublishersNow = getHasPublishers();
                         if (hasResumed) {
                             if (!hasPublishersNow && hasPublishers) {
-                                pushEmitter.emit(constants_1.PUSH_SUBSYSTEM_DOWN);
+                                pushEmitter.emit(constants_2.PUSH_SUBSYSTEM_DOWN);
                             }
                             else if (hasPublishersNow && !hasPublishers) {
-                                pushEmitter.emit(constants_1.PUSH_SUBSYSTEM_UP);
+                                pushEmitter.emit(constants_2.PUSH_SUBSYSTEM_UP);
                             }
                             // nothing to do when hasResumed === false:
                             // streaming is already down for `!hasPublishersNow`, and cannot be up for `hasPublishersNow`
@@ -58,7 +62,7 @@ function notificationKeeperFactory(pushEmitter) {
             /* STREAMING_RESET control event is handled by PushManager directly since it doesn't require
              * tracking timestamp and state like OCCUPANCY or CONTROL. It also ignores previous
              * OCCUPANCY and CONTROL notifications, and whether PUSH_SUBSYSTEM_DOWN has been emitted or not */
-            if (controlType === constants_1.ControlType.STREAMING_RESET) {
+            if (controlType === constants_2.ControlType.STREAMING_RESET) {
                 pushEmitter.emit(controlType);
                 return;
             }
@@ -67,20 +71,23 @@ function notificationKeeperFactory(pushEmitter) {
                 if (c.regex.test(channel)) {
                     if (timestamp > c.cTime) {
                         c.cTime = timestamp;
-                        if (controlType === constants_1.ControlType.STREAMING_DISABLED) {
-                            pushEmitter.emit(constants_1.PUSH_NONRETRYABLE_ERROR);
+                        if (controlType === constants_2.ControlType.STREAMING_DISABLED) {
+                            telemetryTracker.streamingEvent(constants_1.STREAMING_STATUS, constants_1.DISABLED);
+                            pushEmitter.emit(constants_2.PUSH_NONRETRYABLE_ERROR);
                         }
                         else if (hasPublishers) {
-                            if (controlType === constants_1.ControlType.STREAMING_PAUSED && hasResumed) {
-                                pushEmitter.emit(constants_1.PUSH_SUBSYSTEM_DOWN);
+                            if (controlType === constants_2.ControlType.STREAMING_PAUSED && hasResumed) {
+                                telemetryTracker.streamingEvent(constants_1.STREAMING_STATUS, constants_1.PAUSED);
+                                pushEmitter.emit(constants_2.PUSH_SUBSYSTEM_DOWN);
                             }
-                            else if (controlType === constants_1.ControlType.STREAMING_RESUMED && !hasResumed) {
-                                pushEmitter.emit(constants_1.PUSH_SUBSYSTEM_UP);
+                            else if (controlType === constants_2.ControlType.STREAMING_RESUMED && !hasResumed) {
+                                telemetryTracker.streamingEvent(constants_1.STREAMING_STATUS, constants_1.ENABLED);
+                                pushEmitter.emit(constants_2.PUSH_SUBSYSTEM_UP);
                             }
                             // nothing to do when hasPublishers === false:
                             // streaming is already down for `STREAMING_PAUSED`, and cannot be up for `STREAMING_RESUMED`
                         }
-                        hasResumed = controlType === constants_1.ControlType.STREAMING_RESUMED;
+                        hasResumed = controlType === constants_2.ControlType.STREAMING_RESUMED;
                     }
                     return;
                 }

package/cjs/sync/streaming/SSEHandler/index.js

@@ -5,27 +5,33 @@ var NotificationParser_1 = require("./NotificationParser");
 var NotificationKeeper_1 = require("./NotificationKeeper");
 var constants_1 = require("../constants");
 var constants_2 = require("../../../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;
-}
+var constants_3 = require("../../../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
  */
-function SSEHandlerFactory(log, pushEmitter) {
-    var notificationKeeper = (0, NotificationKeeper_1.notificationKeeperFactory)(pushEmitter);
+function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
+    var notificationKeeper = (0, NotificationKeeper_1.notificationKeeperFactory)(pushEmitter, telemetryTracker);
+    function isRetryableError(error) {
+        if (error.parsedData && error.parsedData.code) {
+            // Ably error
+            var code = error.parsedData.code;
+            telemetryTracker.streamingEvent(constants_3.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(constants_3.SSE_CONNECTION_ERROR, constants_3.NON_REQUESTED);
+        }
+        return true;
+    }
     return {
         handleOpen: function () {
             notificationKeeper.handleOpen();

package/cjs/sync/streaming/pushManager.js

@@ -17,13 +17,14 @@ var types_1 = require("./SSEHandler/types");
 var mySegmentsV2utils_1 = require("./mySegmentsV2utils");
 var sets_1 = require("../../utils/lang/sets");
 var murmur3_64_1 = require("../../utils/murmur3/murmur3_64");
+var constants_3 = require("../../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
  */
 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 ? (0, key_1.getMatching)(settings.core.key) : undefined;
@@ -40,7 +41,7 @@ function pushManagerFactory(params, pollingManager) {
     var authenticate = (0, AuthClient_1.authenticateFactory)(splitApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
-    var sseHandler = (0, SSEHandler_1.SSEHandlerFactory)(log, pushEmitter);
+    var sseHandler = (0, SSEHandler_1.SSEHandlerFactory)(log, pushEmitter, telemetryTracker);
     sseClient.setEventHandler(sseHandler);
     // init workers
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
@@ -83,6 +84,7 @@ function pushManagerFactory(params, pollingManager) {
                 return;
             sseClient.open(authData);
         }, connDelay * 1000);
+        telemetryTracker.streamingEvent(constants_3.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)
@@ -113,6 +115,7 @@ function pushManagerFactory(params, pollingManager) {
             log.error(constants_2.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(constants_3.AUTH_REJECTION);
                 pushEmitter.emit(constants_1.PUSH_NONRETRYABLE_ERROR);
                 return;
             }
@@ -153,14 +156,14 @@ 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(constants_1.PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
         disabled = true;
         // Note: `stopWorkers` is been called twice, but it is not harmful
         disconnectPush();
         pushEmitter.emit(constants_1.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(constants_1.PUSH_RETRYABLE_ERROR, function handleRetryableError() {
         // SSE connection is closed to avoid repeated errors due to retries
         sseClient.close();

package/cjs/sync/submitters/eventsSubmitter.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventsSubmitterFactory = void 0;
+var submitter_1 = require("./submitter");
+var constants_1 = require("../../logger/constants");
+var DATA_NAME = 'events';
+/**
+ * Submitter that periodically posts tracked events
+ */
+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 = (0, submitter_1.submitterFactory)(log, postEventsBulk, events, eventsPushRate, DATA_NAME);
+    // Set a timer for the first push window of events.
+    if (eventsFirstPushWindow > 0)
+        submitter = (0, submitter_1.firstPushWindowDecorator)(submitter, eventsFirstPushWindow);
+    // register events submitter to be executed when events cache is full
+    events.setOnFullQueueCb(function () {
+        if (submitter.isRunning()) {
+            log.info(constants_1.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;
+}
+exports.eventsSubmitterFactory = eventsSubmitterFactory;

package/cjs/sync/submitters/{impressionCountsSyncTask.js → impressionCountsSubmitter.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.impressionCountsSyncTaskFactory = exports.fromImpressionCountsCollector = void 0;
-var submitterSyncTask_1 = require("./submitterSyncTask");
+exports.impressionCountsSubmitterFactory = exports.fromImpressionCountsCollector = void 0;
+var submitter_1 = require("./submitter");
 /**
  * Converts `impressionCounts` data from cache into request payload.
  */
@@ -26,10 +26,13 @@ function fromImpressionCountsCollector(impressionsCount) {
 exports.fromImpressionCountsCollector = fromImpressionCountsCollector;
 var IMPRESSIONS_COUNT_RATE = 1800000; // 30 minutes
 /**
- * Sync task that periodically posts impression counts
+ * Submitter that periodically posts impression counts
  */
-function impressionCountsSyncTaskFactory(log, postTestImpressionsCount, impressionCountsCache, latencyTracker) {
-    // retry impressions counts only once.
-    return (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postTestImpressionsCount, impressionCountsCache, IMPRESSIONS_COUNT_RATE, 'impression counts', latencyTracker, fromImpressionCountsCollector, 1);
+function impressionCountsSubmitterFactory(params) {
+    var log = params.settings.log, postTestImpressionsCount = params.splitApi.postTestImpressionsCount, impressionCounts = params.storage.impressionCounts;
+    if (impressionCounts) {
+        // retry impressions counts only once.
+        return (0, submitter_1.submitterFactory)(log, postTestImpressionsCount, impressionCounts, IMPRESSIONS_COUNT_RATE, 'impression counts', fromImpressionCountsCollector, 1);
+    }
 }
-exports.impressionCountsSyncTaskFactory = impressionCountsSyncTaskFactory;
+exports.impressionCountsSubmitterFactory = impressionCountsSubmitterFactory;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.impressionsSyncTaskFactory = exports.fromImpressionsCollector = void 0;
+exports.impressionsSubmitterFactory = exports.fromImpressionsCollector = void 0;
 var lang_1 = require("../../utils/lang");
-var submitterSyncTask_1 = require("./submitterSyncTask");
+var submitter_1 = require("./submitter");
 var constants_1 = require("../../logger/constants");
 var DATA_NAME = 'impressions';
 /**
@@ -33,14 +33,14 @@ function fromImpressionsCollector(sendLabels, data) {
 }
 exports.fromImpressionsCollector = fromImpressionsCollector;
 /**
- * Sync task that periodically posts impressions data
+ * Submitter that periodically posts impressions data
  */
-function impressionsSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, sendLabels, latencyTracker) {
-    if (sendLabels === void 0) { sendLabels = false; }
+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 = (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, DATA_NAME, latencyTracker, fromImpressionsCollector.bind(undefined, sendLabels), 1);
+    var syncTask = (0, submitter_1.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(constants_1.SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
             syncTask.execute();
@@ -50,4 +50,4 @@ function impressionsSyncTaskFactory(log, postTestImpressionsBulk, impressionsCac
     });
     return syncTask;
 }
-exports.impressionsSyncTaskFactory = impressionsSyncTaskFactory;
+exports.impressionsSubmitterFactory = impressionsSubmitterFactory;