@splitsoftware/splitio-commons 1.8.3-rc.3 → 1.8.4-rc.0

package/CHANGES.txt

@@ -1,7 +1,7 @@
-1.8.3 (June 30, 2023)
+1.8.3 (June 29, 2023)
  - Updated some transitive dependencies for vulnerability fixes.
- - Updated SDK_READY_TIMED_OUT event to be emitted immediately when a connection error occurs using pluggable storage (i.e., wrapper `connect` promise is rejected) in consumer and partial consumer modes.
- - Bugfix - The `destroy` method has been updated to immediately flag the SDK client as destroyed, to prevent access to the storage when `getTreatment` and `track` methods are called after the SDK is destroyed.
+ - Updated SDK_READY_TIMED_OUT event to be emitted immediately when a connection error occurs using pluggable storage (i.e., when the wrapper `connect` promise is rejected) in consumer and partial consumer modes.
+ - Bugfix - The `destroy` method has been updated to immediately flag the SDK client as destroyed, to prevent unexpected behaviours when `getTreatment` and `track` methods are called synchronously after `destroy` method is called.
 
 1.8.2 (May 15, 2023)
  - Updated terminology on the SDKs codebase to be more aligned with current standard without causing a breaking change. The core change is the term split for feature flag on things like logs and IntelliSense comments.

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -41,6 +41,10 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         this.tags = [];
         this.exceptions = {};
         this.latencies = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0
+        };
     }
     TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
     TelemetryCacheInMemory.prototype.clear = function () { };
@@ -65,6 +69,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             eD: this.getEventStats(constants_1.DROPPED),
             sE: this.popStreamingEvents(),
             t: this.popTags(),
+            ufs: this.popUpdatesFromSSE(),
         };
     };
     TelemetryCacheInMemory.prototype.getTimeUntilReady = function () {
@@ -188,6 +193,18 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         latencyBuckets[(0, findLatencyIndex_1.findLatencyIndex)(latencyMs)]++;
         this.e = false;
     };
+    TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
+        var result = this.updatesFromSSE;
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0,
+        };
+        return result;
+    };
+    TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
+        this.updatesFromSSE[type]++;
+        this.e = false;
+    };
     return TelemetryCacheInMemory;
 }());
 exports.TelemetryCacheInMemory = TelemetryCacheInMemory;

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

@@ -86,7 +86,7 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
      * @param {boolean | undefined} noCache true to revalidate data to fetch
      * @param {boolean | undefined} till query param to bypass CDN requests
      */
-    return function splitChangesUpdater(noCache, till) {
+    return function splitChangesUpdater(noCache, till, splitUpdateNotification) {
         /**
          * @param {number} since current changeNumber at splitsCache
          * @param {number} retry current number of retry attempts
@@ -94,7 +94,9 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(constants_2.SYNC_SPLITS_FETCH, [since]);
-            var fetcherPromise = splitChangesFetcher(since, noCache, till, _promiseDecorator)
+            var fetcherPromise = Promise.resolve(splitUpdateNotification ?
+                { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
+                splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
                 startingUp = false;
                 var mutation = computeSplitsMutation(splitChanges.splits);

package/cjs/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySegmentsUpdateWorker = void 0;
 var Backoff_1 = require("../../../utils/Backoff");
+var constants_1 = require("../../../utils/constants");
 /**
  * MySegmentsUpdateWorker factory
  */
-function MySegmentsUpdateWorker(mySegmentsSyncTask) {
+function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) {
     var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
     var currentChangeNumber = -1;
     var handleNewEvent = false;
@@ -21,8 +22,11 @@ function MySegmentsUpdateWorker(mySegmentsSyncTask) {
             mySegmentsSyncTask.execute(_segmentsData, true).then(function (result) {
                 if (!isHandlingEvent)
                     return; // halt if `stop` has been called
-                if (result !== false) // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
+                if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
+                    if (_segmentsData)
+                        telemetryTracker.trackUpdatesFromSSE(constants_1.MY_SEGMENT);
                     currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+                }
                 if (handleNewEvent) {
                     __handleMySegmentsUpdateCall();
                 }

package/cjs/sync/streaming/UpdateWorkers/SplitsUpdateWorker.js

@@ -3,28 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SplitsUpdateWorker = void 0;
 var constants_1 = require("../../../readiness/constants");
 var Backoff_1 = require("../../../utils/Backoff");
-var constants_2 = require("./constants");
+var constants_2 = require("../../../utils/constants");
+var constants_3 = require("./constants");
 /**
  * SplitsUpdateWorker factory
  */
-function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter, segmentsSyncTask) {
+function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter, telemetryTracker, segmentsSyncTask) {
     var maxChangeNumber = 0;
     var handleNewEvent = false;
     var isHandlingEvent;
     var cdnBypass;
-    var backoff = new Backoff_1.Backoff(__handleSplitUpdateCall, constants_2.FETCH_BACKOFF_BASE, constants_2.FETCH_BACKOFF_MAX_WAIT);
+    var payload;
+    var backoff = new Backoff_1.Backoff(__handleSplitUpdateCall, constants_3.FETCH_BACKOFF_BASE, constants_3.FETCH_BACKOFF_MAX_WAIT);
     function __handleSplitUpdateCall() {
         isHandlingEvent = true;
         if (maxChangeNumber > splitsCache.getChangeNumber()) {
             handleNewEvent = false;
+            var splitUpdateNotification_1 = payload ? { payload: payload, changeNumber: maxChangeNumber } : undefined;
             // fetch splits revalidating data if cached
-            splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined).then(function () {
+            splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, splitUpdateNotification_1).then(function () {
                 if (!isHandlingEvent)
                     return; // halt if `stop` has been called
                 if (handleNewEvent) {
                     __handleSplitUpdateCall();
                 }
                 else {
+                    if (splitUpdateNotification_1)
+                        telemetryTracker.trackUpdatesFromSSE(constants_2.SPLITS);
                     // fetch new registered segments for server-side API. Not retrying on error
                     if (segmentsSyncTask)
                         segmentsSyncTask.execute(true);
@@ -34,7 +39,7 @@ function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter
                         isHandlingEvent = false;
                         return;
                     }
-                    if (attempts < constants_2.FETCH_BACKOFF_MAX_RETRIES) {
+                    if (attempts < constants_3.FETCH_BACKOFF_MAX_RETRIES) {
                         backoff.scheduleCall();
                         return;
                     }
@@ -59,14 +64,18 @@ function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter
      *
      * @param {number} changeNumber change number of the SPLIT_UPDATE notification
      */
-    function put(_a) {
-        var changeNumber = _a.changeNumber;
+    function put(_a, _payload) {
+        var changeNumber = _a.changeNumber, pcn = _a.pcn;
         var currentChangeNumber = splitsCache.getChangeNumber();
         if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
             return;
         maxChangeNumber = changeNumber;
         handleNewEvent = true;
         cdnBypass = false;
+        payload = undefined;
+        if (_payload && currentChangeNumber === pcn) {
+            payload = _payload;
+        }
         if (backoff.timeoutID || !isHandlingEvent)
             __handleSplitUpdateCall();
         backoff.reset();

package/cjs/sync/streaming/pushManager.js

@@ -47,7 +47,7 @@ function pushManagerFactory(params, pollingManager) {
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
     var segmentsUpdateWorker = userKey ? undefined : (0, SegmentsUpdateWorker_1.SegmentsUpdateWorker)(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-    var splitsUpdateWorker = (0, SplitsUpdateWorker_1.SplitsUpdateWorker)(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
+    var splitsUpdateWorker = (0, SplitsUpdateWorker_1.SplitsUpdateWorker)(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
     // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
     var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
@@ -183,7 +183,22 @@ function pushManagerFactory(params, pollingManager) {
     });
     /** Functions related to synchronization (Queues and Workers in the spec) */
     pushEmitter.on(constants_1.SPLIT_KILL, splitsUpdateWorker.killSplit);
-    pushEmitter.on(constants_1.SPLIT_UPDATE, splitsUpdateWorker.put);
+    pushEmitter.on(constants_1.SPLIT_UPDATE, function (parsedData) {
+        if (parsedData.d && parsedData.c !== undefined) {
+            try {
+                var payload = (0, parseUtils_1.parseFFUpdatePayload)(parsedData.c, parsedData.d);
+                if (payload) {
+                    splitsUpdateWorker.put(parsedData, payload);
+                    return;
+                }
+            }
+            catch (e) {
+                // @TODO define a error code for feature flags parsing
+                log.debug(e);
+            }
+        }
+        splitsUpdateWorker.put(parsedData);
+    });
     if (userKey) {
         pushEmitter.on(constants_1.MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
             var userKeyHash = channel.split('_')[2];
@@ -289,7 +304,7 @@ function pushManagerFactory(params, pollingManager) {
             var hash = (0, AuthClient_1.hashUserKey)(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
-                clients[userKey] = { hash64: (0, murmur3_64_1.hash64)(userKey), worker: (0, MySegmentsUpdateWorker_1.MySegmentsUpdateWorker)(mySegmentsSyncTask) };
+                clients[userKey] = { hash64: (0, murmur3_64_1.hash64)(userKey), worker: (0, MySegmentsUpdateWorker_1.MySegmentsUpdateWorker)(mySegmentsSyncTask, telemetryTracker) };
                 connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
                 // Reconnects in case of a new client.
                 // Run in next event-loop cycle to save authentication calls

package/cjs/trackers/telemetryTracker.js

@@ -54,6 +54,9 @@ function telemetryTrackerFactory(telemetryCache, now) {
                 // @ts-ignore
                 if (telemetryCache.addTag)
                     telemetryCache.addTag(tag);
+            },
+            trackUpdatesFromSSE: function (type) {
+                telemetryCache.recordUpdatesFromSSE(type);
             }
         };
     }
@@ -64,7 +67,8 @@ function telemetryTrackerFactory(telemetryCache, now) {
             trackHttp: noopTrack,
             sessionLength: function () { },
             streamingEvent: function () { },
-            addTag: function () { }
+            addTag: function () { },
+            trackUpdatesFromSSE: function () { },
         };
     }
 }

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -36,6 +36,10 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         this.tags = [];
         this.exceptions = {};
         this.latencies = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0
+        };
     }
     TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
     TelemetryCacheInMemory.prototype.clear = function () { };
@@ -60,6 +64,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             eD: this.getEventStats(DROPPED),
             sE: this.popStreamingEvents(),
             t: this.popTags(),
+            ufs: this.popUpdatesFromSSE(),
         };
     };
     TelemetryCacheInMemory.prototype.getTimeUntilReady = function () {
@@ -183,6 +188,18 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         latencyBuckets[findLatencyIndex(latencyMs)]++;
         this.e = false;
     };
+    TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
+        var result = this.updatesFromSSE;
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0,
+        };
+        return result;
+    };
+    TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
+        this.updatesFromSSE[type]++;
+        this.e = false;
+    };
     return TelemetryCacheInMemory;
 }());
 export { TelemetryCacheInMemory };

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

@@ -81,7 +81,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
      * @param {boolean | undefined} noCache true to revalidate data to fetch
      * @param {boolean | undefined} till query param to bypass CDN requests
      */
-    return function splitChangesUpdater(noCache, till) {
+    return function splitChangesUpdater(noCache, till, splitUpdateNotification) {
         /**
          * @param {number} since current changeNumber at splitsCache
          * @param {number} retry current number of retry attempts
@@ -89,7 +89,9 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(SYNC_SPLITS_FETCH, [since]);
-            var fetcherPromise = splitChangesFetcher(since, noCache, till, _promiseDecorator)
+            var fetcherPromise = Promise.resolve(splitUpdateNotification ?
+                { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
+                splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
                 startingUp = false;
                 var mutation = computeSplitsMutation(splitChanges.splits);

package/esm/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.js

@@ -1,8 +1,9 @@
 import { Backoff } from '../../../utils/Backoff';
+import { MY_SEGMENT } from '../../../utils/constants';
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask) {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) {
     var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
     var currentChangeNumber = -1;
     var handleNewEvent = false;
@@ -18,8 +19,11 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask) {
             mySegmentsSyncTask.execute(_segmentsData, true).then(function (result) {
                 if (!isHandlingEvent)
                     return; // halt if `stop` has been called
-                if (result !== false) // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
+                if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
+                    if (_segmentsData)
+                        telemetryTracker.trackUpdatesFromSSE(MY_SEGMENT);
                     currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+                }
                 if (handleNewEvent) {
                     __handleMySegmentsUpdateCall();
                 }

package/esm/sync/streaming/UpdateWorkers/SplitsUpdateWorker.js

@@ -1,27 +1,32 @@
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { Backoff } from '../../../utils/Backoff';
+import { SPLITS } from '../../../utils/constants';
 import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
 /**
  * SplitsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter, segmentsSyncTask) {
+export function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter, telemetryTracker, segmentsSyncTask) {
     var maxChangeNumber = 0;
     var handleNewEvent = false;
     var isHandlingEvent;
     var cdnBypass;
+    var payload;
     var backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
     function __handleSplitUpdateCall() {
         isHandlingEvent = true;
         if (maxChangeNumber > splitsCache.getChangeNumber()) {
             handleNewEvent = false;
+            var splitUpdateNotification_1 = payload ? { payload: payload, changeNumber: maxChangeNumber } : undefined;
             // fetch splits revalidating data if cached
-            splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined).then(function () {
+            splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined, splitUpdateNotification_1).then(function () {
                 if (!isHandlingEvent)
                     return; // halt if `stop` has been called
                 if (handleNewEvent) {
                     __handleSplitUpdateCall();
                 }
                 else {
+                    if (splitUpdateNotification_1)
+                        telemetryTracker.trackUpdatesFromSSE(SPLITS);
                     // fetch new registered segments for server-side API. Not retrying on error
                     if (segmentsSyncTask)
                         segmentsSyncTask.execute(true);
@@ -56,14 +61,18 @@ export function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEvent
      *
      * @param {number} changeNumber change number of the SPLIT_UPDATE notification
      */
-    function put(_a) {
-        var changeNumber = _a.changeNumber;
+    function put(_a, _payload) {
+        var changeNumber = _a.changeNumber, pcn = _a.pcn;
         var currentChangeNumber = splitsCache.getChangeNumber();
         if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
             return;
         maxChangeNumber = changeNumber;
         handleNewEvent = true;
         cdnBypass = false;
+        payload = undefined;
+        if (_payload && currentChangeNumber === pcn) {
+            payload = _payload;
+        }
         if (backoff.timeoutID || !isHandlingEvent)
             __handleSplitUpdateCall();
         backoff.reset();

package/esm/sync/streaming/pushManager.js

@@ -11,7 +11,7 @@ import { getMatching } from '../../utils/key';
 import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
-import { isInBitmap, parseBitmap, parseKeyList } from './parseUtils';
+import { isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { _Set } from '../../utils/lang/sets';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
@@ -44,7 +44,7 @@ export function pushManagerFactory(params, pollingManager) {
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
     var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-    var splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
+    var splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask);
     // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
     var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
@@ -180,7 +180,22 @@ export function pushManagerFactory(params, pollingManager) {
     });
     /** Functions related to synchronization (Queues and Workers in the spec) */
     pushEmitter.on(SPLIT_KILL, splitsUpdateWorker.killSplit);
-    pushEmitter.on(SPLIT_UPDATE, splitsUpdateWorker.put);
+    pushEmitter.on(SPLIT_UPDATE, function (parsedData) {
+        if (parsedData.d && parsedData.c !== undefined) {
+            try {
+                var payload = parseFFUpdatePayload(parsedData.c, parsedData.d);
+                if (payload) {
+                    splitsUpdateWorker.put(parsedData, payload);
+                    return;
+                }
+            }
+            catch (e) {
+                // @TODO define a error code for feature flags parsing
+                log.debug(e);
+            }
+        }
+        splitsUpdateWorker.put(parsedData);
+    });
     if (userKey) {
         pushEmitter.on(MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
             var userKeyHash = channel.split('_')[2];
@@ -286,7 +301,7 @@ export function pushManagerFactory(params, pollingManager) {
             var hash = hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
-                clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(mySegmentsSyncTask) };
+                clients[userKey] = { hash64: hash64(userKey), worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) };
                 connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
                 // Reconnects in case of a new client.
                 // Run in next event-loop cycle to save authentication calls

package/esm/trackers/telemetryTracker.js

@@ -51,6 +51,9 @@ export function telemetryTrackerFactory(telemetryCache, now) {
                 // @ts-ignore
                 if (telemetryCache.addTag)
                     telemetryCache.addTag(tag);
+            },
+            trackUpdatesFromSSE: function (type) {
+                telemetryCache.recordUpdatesFromSSE(type);
             }
         };
     }
@@ -61,7 +64,8 @@ export function telemetryTrackerFactory(telemetryCache, now) {
             trackHttp: noopTrack,
             sessionLength: function () { },
             streamingEvent: function () { },
-            addTag: function () { }
+            addTag: function () { },
+            trackUpdatesFromSSE: function () { },
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.8.3-rc.3",
+  "version": "1.8.4-rc.0",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -22,7 +22,7 @@
     "build": "npm run build:cjs && npm run build:esm",
     "build:esm": "rimraf esm && tsc -m es2015 --outDir esm -d true --declarationDir types",
     "build:cjs": "rimraf cjs && tsc -m CommonJS --outDir cjs",
-    "test": "jest --runInBand",
+    "test": "jest",
     "test:coverage": "jest --coverage",
     "all": "npm run check && npm run build && npm run test",
     "publish:rc": "npm run check && npm run test && npm run build && npm publish --tag rc",

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -1,4 +1,4 @@
-import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies, TelemetryUsageStatsPayload } from '../../sync/submitters/types';
+import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../../sync/submitters/types';
 import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
@@ -56,6 +56,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
       eD: this.getEventStats(DROPPED),
       sE: this.popStreamingEvents(),
       t: this.popTags(),
+      ufs: this.popUpdatesFromSSE(),
     };
   }
 
@@ -244,4 +245,23 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     this.e = false;
   }
 
+  private updatesFromSSE = {
+    sp: 0,
+    ms: 0
+  };
+
+  popUpdatesFromSSE() {
+    const result = this.updatesFromSSE;
+    this.updatesFromSSE = {
+      sp: 0,
+      ms: 0,
+    };
+    return result;
+  }
+
+  recordUpdatesFromSSE(type: UpdatesFromSSEEnum) {
+    this.updatesFromSSE[type]++;
+    this.e = false;
+  }
+
 }

package/src/storages/types.ts

@@ -1,5 +1,5 @@
 import { MaybeThenable, ISplit } from '../dtos/types';
-import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload } from '../sync/submitters/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
 
 /**
@@ -409,6 +409,7 @@ export interface ITelemetryRuntimeProducerSync {
   recordTokenRefreshes(): void;
   recordStreamingEvents(streamingEvent: StreamingEvent): void;
   recordSessionLength(ms: number): void;
+  recordUpdatesFromSSE(type: UpdatesFromSSEEnum): void
 }
 
 export interface ITelemetryEvaluationProducerSync {

package/src/sync/polling/types.ts

@@ -1,8 +1,9 @@
+import { ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
 import { ITask, ISyncTask } from '../types';
 
-export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number], boolean> { }
+export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }], boolean> { }
 
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
 

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

@@ -8,7 +8,7 @@ import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/
 import { ILogger } from '../../../logger/types';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 
-type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promise<boolean>
+type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) => Promise<boolean>
 
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
@@ -111,7 +111,7 @@ export function splitChangesUpdaterFactory(
    * @param {boolean | undefined} noCache true to revalidate data to fetch
    * @param {boolean | undefined} till query param to bypass CDN requests
    */
-  return function splitChangesUpdater(noCache?: boolean, till?: number) {
+  return function splitChangesUpdater(noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) {
 
     /**
      * @param {number} since current changeNumber at splitsCache
@@ -119,8 +119,10 @@ export function splitChangesUpdaterFactory(
      */
     function _splitChangesUpdater(since: number, retry = 0): Promise<boolean> {
       log.debug(SYNC_SPLITS_FETCH, [since]);
-
-      const fetcherPromise = splitChangesFetcher(since, noCache, till, _promiseDecorator)
+      const fetcherPromise = Promise.resolve(splitUpdateNotification ?
+        { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
+        splitChangesFetcher(since, noCache, till, _promiseDecorator)
+      )
         .then((splitChanges: ISplitChangesResponse) => {
           startingUp = false;
 

package/src/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.ts

@@ -1,11 +1,13 @@
 import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
 import { Backoff } from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
+import { MY_SEGMENT } from '../../../utils/constants';
+import { ITelemetryTracker } from '../../../trackers/types';
 
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask): IUpdateWorker {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker {
 
   let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
   let currentChangeNumber = -1;
@@ -23,8 +25,10 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask):
       // fetch mySegments revalidating data if cached
       mySegmentsSyncTask.execute(_segmentsData, true).then((result) => {
         if (!isHandlingEvent) return; // halt if `stop` has been called
-        if (result !== false) // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
+        if (result !== false) {// Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
+          if (_segmentsData) telemetryTracker.trackUpdatesFromSSE(MY_SEGMENT);
           currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+        }
         if (handleNewEvent) {
           __handleMySegmentsUpdateCall();
         } else {