@splitsoftware/splitio-commons 0.1.1-canary.6 → 0.1.1-rc.18

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

@@ -13,7 +13,7 @@ var MySegmentsUpdateWorker = /** @class */ (function () {
         this.mySegmentsSyncTask = mySegmentsSyncTask;
         this.maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
         this.handleNewEvent = false;
-        this.segmentList = undefined; // keeps the segmentList (if included in payload) from the queued event with maximum changeNumber
+        this.segmentsData = undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
         this.currentChangeNumber = -1; // @TODO: remove once `/mySegments` endpoint provides the changeNumber
         this.put = this.put.bind(this);
         this.__handleMySegmentsUpdateCall = this.__handleMySegmentsUpdateCall.bind(this);
@@ -27,7 +27,7 @@ var MySegmentsUpdateWorker = /** @class */ (function () {
             this.handleNewEvent = false;
             var currentMaxChangeNumber_1 = this.maxChangeNumber;
             // fetch mySegments revalidating data if cached
-            this.mySegmentsSyncTask.execute(this.segmentList, true).then(function (result) {
+            this.mySegmentsSyncTask.execute(this.segmentsData, true).then(function (result) {
                 if (result !== false) // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
                     _this.currentChangeNumber = Math.max(_this.currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
                 if (_this.handleNewEvent) {
@@ -43,15 +43,15 @@ var MySegmentsUpdateWorker = /** @class */ (function () {
      * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
      *
      * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-     * @param {string[] | undefined} segmentList might be undefined
+     * @param {SegmentsData | undefined} segmentsData might be undefined
      */
-    MySegmentsUpdateWorker.prototype.put = function (changeNumber, segmentList) {
+    MySegmentsUpdateWorker.prototype.put = function (changeNumber, segmentsData) {
         if (changeNumber <= this.currentChangeNumber || changeNumber <= this.maxChangeNumber)
             return;
         this.maxChangeNumber = changeNumber;
         this.handleNewEvent = true;
         this.backoff.reset();
-        this.segmentList = segmentList;
+        this.segmentsData = segmentsData;
         if (this.mySegmentsSyncTask.isExecuting())
             return;
         this.__handleMySegmentsUpdateCall();

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

@@ -57,7 +57,8 @@ var SegmentsUpdateWorker = /** @class */ (function () {
      * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
      * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
      */
-    SegmentsUpdateWorker.prototype.put = function (changeNumber, segmentName) {
+    SegmentsUpdateWorker.prototype.put = function (_a) {
+        var changeNumber = _a.changeNumber, segmentName = _a.segmentName;
         var currentChangeNumber = this.segmentsCache.getChangeNumber(segmentName);
         if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumbers[segmentName])
             return;

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

@@ -49,7 +49,8 @@ var SplitsUpdateWorker = /** @class */ (function () {
      *
      * @param {number} changeNumber change number of the SPLIT_UPDATE notification
      */
-    SplitsUpdateWorker.prototype.put = function (changeNumber) {
+    SplitsUpdateWorker.prototype.put = function (_a) {
+        var changeNumber = _a.changeNumber;
         var currentChangeNumber = this.splitsCache.getChangeNumber();
         if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber)
             return;
@@ -67,14 +68,15 @@ var SplitsUpdateWorker = /** @class */ (function () {
      * @param {string} splitName name of split to kill
      * @param {string} defaultTreatment default treatment value
      */
-    SplitsUpdateWorker.prototype.killSplit = function (changeNumber, splitName, defaultTreatment) {
+    SplitsUpdateWorker.prototype.killSplit = function (_a) {
+        var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
         // @TODO handle retry due to errors in storage, once we allow the definition of custom async storages
         if (this.splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
             // trigger an SDK_UPDATE if Split was killed locally
             this.splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED, true);
         }
         // queues the SplitChanges fetch (only if changeNumber is newer)
-        this.put(changeNumber);
+        this.put({ changeNumber: changeNumber });
     };
     return SplitsUpdateWorker;
 }());

package/cjs/sync/streaming/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControlType = exports.OCCUPANCY = exports.CONTROL = exports.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = exports.MY_SEGMENTS_UPDATE = exports.PUSH_SUBSYSTEM_DOWN = exports.PUSH_SUBSYSTEM_UP = exports.PUSH_RETRYABLE_ERROR = exports.PUSH_NONRETRYABLE_ERROR = exports.SECONDS_BEFORE_EXPIRATION = void 0;
+exports.ControlType = exports.OCCUPANCY = exports.CONTROL = exports.SPLIT_UPDATE = exports.SPLIT_KILL = exports.SEGMENT_UPDATE = exports.MY_SEGMENTS_UPDATE_V2 = exports.MY_SEGMENTS_UPDATE = exports.PUSH_SUBSYSTEM_DOWN = exports.PUSH_SUBSYSTEM_UP = exports.PUSH_RETRYABLE_ERROR = exports.PUSH_NONRETRYABLE_ERROR = exports.SECONDS_BEFORE_EXPIRATION = void 0;
 // time for refresh token
 exports.SECONDS_BEFORE_EXPIRATION = 600;
 // Internal SDK events, subscribed by SyncManager and PushManager
@@ -26,6 +26,7 @@ exports.PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 exports.PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 // Update-type push notifications, handled by NotificationProcessor
 exports.MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
+exports.MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 exports.SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 exports.SPLIT_KILL = 'SPLIT_KILL';
 exports.SPLIT_UPDATE = 'SPLIT_UPDATE';
@@ -37,4 +38,5 @@ var ControlType;
     ControlType["STREAMING_DISABLED"] = "STREAMING_DISABLED";
     ControlType["STREAMING_PAUSED"] = "STREAMING_PAUSED";
     ControlType["STREAMING_RESUMED"] = "STREAMING_RESUMED";
+    ControlType["STREAMING_RESET"] = "STREAMING_RESET";
 })(ControlType = exports.ControlType || (exports.ControlType = {}));

package/cjs/sync/streaming/mySegmentsV2utils.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInBitmap = exports.parseBitmap = exports.parseKeyList = void 0;
+var decompress_1 = require("../../utils/decompress");
+var base64_1 = require("../../utils/base64");
+var GZIP = 1;
+var ZLIB = 2;
+function Uint8ArrayToString(myUint8Arr) {
+    return String.fromCharCode.apply(null, myUint8Arr);
+}
+function StringToUint8Array(myString) {
+    var charCodes = myString.split('').map(function (e) { return e.charCodeAt(0); });
+    return new Uint8Array(charCodes);
+}
+/**
+ * Decode and decompress 'data' with 'compression' algorithm
+ *
+ * @param {string} data
+ * @param {number} compression 1 GZIP, 2 ZLIB
+ * @returns {Uint8Array}
+ * @throws if data string cannot be decoded, decompressed or the provided compression value is invalid (not 1 or 2)
+ */
+function decompress(data, compression) {
+    var compressData = base64_1.decodeFromBase64(data);
+    var binData = StringToUint8Array(compressData);
+    if (typeof decompress_1.algorithms === 'string')
+        throw new Error(decompress_1.algorithms);
+    if (compression === GZIP)
+        return decompress_1.algorithms.gunzipSync(binData);
+    if (compression === ZLIB)
+        return decompress_1.algorithms.unzlibSync(binData);
+    throw new Error("Invalid compression algorithm #" + compression);
+}
+/**
+ * Decode, decompress and parse the provided 'data' into a KeyList object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {{a?: string[], r?: string[] }}
+ * @throws if data string cannot be decoded, decompressed or parsed
+ */
+function parseKeyList(data, compression) {
+    var binKeyList = decompress(data, compression);
+    var strKeyList = Uint8ArrayToString(binKeyList);
+    // replace numbers to strings, to avoid losing precision
+    return JSON.parse(strKeyList.replace(/\d+/g, '"$&"'));
+}
+exports.parseKeyList = parseKeyList;
+/**
+ * Decode, decompress and parse the provided 'data' into a Bitmap object
+ *
+ * @param {string} data
+ * @param {number} compression
+ * @returns {Uint8Array}
+ * @throws if data string cannot be decoded or decompressed
+ */
+function parseBitmap(data, compression) {
+    return decompress(data, compression);
+}
+exports.parseBitmap = parseBitmap;
+/**
+ * Check if the 'bitmap' bit at 'hash64hex' position is 1
+ *
+ * @param {Uint8Array} bitmap
+ * @param {string} hash64hex 16-chars string, representing a number in hexa
+ * @returns {boolean}
+ */
+function isInBitmap(bitmap, hash64hex) {
+    // using the lowest 32 bits as index, to avoid losing precision when converting to number
+    var index = parseInt(hash64hex.slice(8), 16) % (bitmap.length * 8);
+    var internal = Math.floor(index / 8);
+    var offset = index % 8;
+    return (bitmap[internal] & 1 << offset) > 0;
+}
+exports.isInBitmap = isInBitmap;

package/cjs/sync/streaming/pushManager.js

@@ -13,16 +13,24 @@ var SSEClient_1 = tslib_1.__importDefault(require("./SSEClient"));
 var key_1 = require("../../utils/key");
 var constants_1 = require("./constants");
 var constants_2 = require("../../logger/constants");
+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");
 /**
  * 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(pollingManager, storage, readiness, fetchAuth, platform, settings) {
+    // `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 ? key_1.getMatching(settings.core.key) : undefined; //
     var log = settings.log;
     var sseClient;
     try {
-        sseClient = new SSEClient_1.default(settings.urls.streaming, platform.getEventSource);
+        // `useHeaders` false for client-side, even if the platform EventSource supports headers (e.g., React Native).
+        sseClient = new SSEClient_1.default(settings, userKey ? false : true, platform.getEventSource);
     }
     catch (e) {
         log.warn(constants_2.STREAMING_FALLBACK, [e]);
@@ -33,44 +41,58 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = SSEHandler_1.default(log, pushEmitter);
     sseClient.setEventHandler(sseHandler);
+    // init workers
+    var segmentsUpdateWorker = userKey ? new MySegmentsUpdateWorker_1.default(pollingManager.segmentsSyncTask) : new SegmentsUpdateWorker_1.default(storage.segments, pollingManager.segmentsSyncTask);
+    // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
+    var splitsUpdateWorker = new SplitsUpdateWorker_1.default(storage.splits, pollingManager.splitsSyncTask, readiness.splits, 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 = {};
-    var userKey = settings.core.key ? key_1.getMatching(settings.core.key) : undefined; // matching key of main client
+    // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
+    // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
+    var clients = {};
     if (userKey) {
         var hash = AuthClient_1.hashUserKey(userKey);
         userKeyHashes[hash] = userKey;
+        clients[userKey] = { hash64: murmur3_64_1.hash64(userKey), worker: segmentsUpdateWorker };
     }
-    // init workers
-    var segmentsUpdateWorker = userKey ? new MySegmentsUpdateWorker_1.default(pollingManager.segmentsSyncTask) : new SegmentsUpdateWorker_1.default(storage.segments, pollingManager.segmentsSyncTask);
-    // [Only for server-side] we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-    var splitsUpdateWorker = new SplitsUpdateWorker_1.default(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
-    // [Only for client-side] map of user keys to their corresponding MySegmentsUpdateWorkers. It has a two-fold intention:
-    // - stop workers all together when push is disconnected
-    // - keep the current list of user keys to authenticate
-    var workers = {};
-    if (userKey)
-        workers[userKey] = segmentsUpdateWorker;
     // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
     var connectForNewClient = false;
-    // flag that indicates if `disconnectPush` was called, either by the SyncManager (when the client is destroyed) or by a PUSH_NONRETRYABLE_ERROR error.
+    // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NONRETRYABLE_ERROR error.
     // It is used to halt the `connectPush` process if it was in progress.
     var disconnected;
+    // flag that indicates a PUSH_NONRETRYABLE_ERROR, condition with which starting pushManager again is ignored.
+    var disabled; // `disabled` implies `disconnected === true`
     /** PushManager functions related to initialization */
     var connectPushRetryBackoff = new Backoff_1.default(connectPush, settings.scheduler.pushRetryBackoffBase);
-    var timeoutId;
-    function scheduleTokenRefresh(issuedAt, expirationTime) {
-        // clear scheduled token refresh if exists (needed when resuming PUSH)
-        if (timeoutId)
-            clearTimeout(timeoutId);
-        // Set token refresh 10 minutes before expirationTime
-        var delayInSeconds = expirationTime - issuedAt - constants_1.SECONDS_BEFORE_EXPIRATION;
-        log.info(constants_2.STREAMING_REFRESH_TOKEN, [delayInSeconds]);
-        timeoutId = setTimeout(connectPush, delayInSeconds * 1000);
+    var timeoutIdTokenRefresh;
+    var timeoutIdSseOpen;
+    function scheduleTokenRefreshAndSse(authData) {
+        // clear scheduled tasks if exist
+        if (timeoutIdTokenRefresh)
+            clearTimeout(timeoutIdTokenRefresh);
+        if (timeoutIdSseOpen)
+            clearTimeout(timeoutIdSseOpen);
+        // Set token refresh 10 minutes before `expirationTime - issuedAt`
+        var decodedToken = authData.decodedToken;
+        var refreshTokenDelay = decodedToken.exp - decodedToken.iat - constants_1.SECONDS_BEFORE_EXPIRATION;
+        // Default connDelay of 60 secs
+        var connDelay = typeof authData.connDelay === 'number' && authData.connDelay >= 0 ? authData.connDelay : 60;
+        log.info(constants_2.STREAMING_REFRESH_TOKEN, [refreshTokenDelay, connDelay]);
+        timeoutIdTokenRefresh = setTimeout(connectPush, refreshTokenDelay * 1000);
+        timeoutIdSseOpen = setTimeout(function () {
+            // halt if disconnected
+            if (disconnected)
+                return;
+            sseClient.open(authData);
+        }, connDelay * 1000);
     }
     function connectPush() {
+        // Guard condition in case `stop/disconnectPush` has been called (e.g., calling SDK destroy, or app signal close/background)
+        if (disconnected)
+            return;
+        log.info(constants_2.STREAMING_CONNECTING, [disconnected === undefined ? '' : 'Re-']);
         disconnected = false;
-        log.info(constants_2.STREAMING_CONNECTING);
-        var userKeys = userKey ? Object.keys(workers) : undefined;
+        var userKeys = userKey ? Object.keys(clients) : undefined;
         authenticate(userKeys).then(function (authData) {
             if (disconnected)
                 return;
@@ -82,12 +104,10 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
                 return;
             }
             // [Only for client-side] don't open SSE connection if a new shared client was added, since it means that a new authentication is taking place
-            if (userKeys && userKeys.length < Object.keys(workers).length)
+            if (userKeys && userKeys.length < Object.keys(clients).length)
                 return;
-            // Connect to SSE and schedule refresh token
-            var decodedToken = authData.decodedToken;
-            sseClient.open(authData);
-            scheduleTokenRefresh(decodedToken.iat, decodedToken.exp);
+            // Schedule SSE connection and refresh token
+            scheduleTokenRefreshAndSse(authData);
         }).catch(function (error) {
             if (disconnected)
                 return;
@@ -103,11 +123,16 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
     }
     // close SSE connection and cancel scheduled tasks
     function disconnectPush() {
+        // Halt disconnecting, just to avoid redundant logs if called multiple times
+        if (disconnected)
+            return;
         disconnected = true;
-        log.info(constants_2.STREAMING_DISCONNECTING);
         sseClient.close();
-        if (timeoutId)
-            clearTimeout(timeoutId);
+        log.info(constants_2.STREAMING_DISCONNECTING);
+        if (timeoutIdTokenRefresh)
+            clearTimeout(timeoutIdTokenRefresh);
+        if (timeoutIdSseOpen)
+            clearTimeout(timeoutIdSseOpen);
         connectPushRetryBackoff.reset();
         stopWorkers();
     }
@@ -115,15 +140,23 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
     function stopWorkers() {
         splitsUpdateWorker.backoff.reset();
         if (userKey)
-            lang_1.forOwn(workers, function (worker) { return worker.backoff.reset(); });
+            lang_1.forOwn(clients, function (_a) {
+                var worker = _a.worker;
+                return worker.backoff.reset();
+            });
         else
             segmentsUpdateWorker.backoff.reset();
     }
     pushEmitter.on(constants_1.PUSH_SUBSYSTEM_DOWN, stopWorkers);
-    // restart backoff retry counter once push is connected
-    pushEmitter.on(constants_1.PUSH_SUBSYSTEM_UP, function () { connectPushRetryBackoff.reset(); });
+    // Only required when streaming connects after a PUSH_RETRYABLE_ERROR.
+    // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
+    pushEmitter.on(constants_1.PUSH_SUBSYSTEM_UP, function () {
+        connectPushRetryBackoff.reset();
+        stopWorkers();
+    });
     /** Fallbacking 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
@@ -137,6 +170,16 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
         log.info(constants_2.STREAMING_RECONNECT, [delayInMillis / 1000]);
         pushEmitter.emit(constants_1.PUSH_SUBSYSTEM_DOWN); // no harm if polling already
     });
+    /** STREAMING_RESET notification. Unlike a PUSH_RETRYABLE_ERROR, it doesn't emit PUSH_SUBSYSTEM_DOWN to fallback polling */
+    pushEmitter.on(constants_1.ControlType.STREAMING_RESET, function handleStreamingReset() {
+        if (disconnected)
+            return; // should never happen
+        // Minimum required clean-up.
+        // `disconnectPush` cannot be called because it sets `disconnected` and thus `connectPush` will not execute
+        if (timeoutIdTokenRefresh)
+            clearTimeout(timeoutIdTokenRefresh);
+        connectPush();
+    });
     /** 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);
@@ -144,11 +187,72 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
         pushEmitter.on(constants_1.MY_SEGMENTS_UPDATE, function handleMySegmentsUpdate(parsedData, channel) {
             var userKeyHash = channel.split('_')[2];
             var userKey = userKeyHashes[userKeyHash];
-            if (userKey && workers[userKey]) { // check context since it can be undefined if client has been destroyed
-                var mySegmentsUpdateWorker = workers[userKey];
-                mySegmentsUpdateWorker.put(parsedData.changeNumber, parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
+            if (userKey && clients[userKey]) { // check existence since it can be undefined if client has been destroyed
+                clients[userKey].worker.put(parsedData.changeNumber, parsedData.includesPayload ? parsedData.segmentList ? parsedData.segmentList : [] : undefined);
             }
         });
+        pushEmitter.on(constants_1.MY_SEGMENTS_UPDATE_V2, function handleMySegmentsUpdate(parsedData) {
+            switch (parsedData.u) {
+                case types_1.UpdateStrategy.BoundedFetchRequest: {
+                    var bitmap_1;
+                    try {
+                        bitmap_1 = mySegmentsV2utils_1.parseBitmap(parsedData.d, parsedData.c);
+                    }
+                    catch (e) {
+                        log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
+                        break;
+                    }
+                    lang_1.forOwn(clients, function (_a) {
+                        var hash64 = _a.hash64, worker = _a.worker;
+                        if (mySegmentsV2utils_1.isInBitmap(bitmap_1, hash64.hex)) {
+                            worker.put(parsedData.changeNumber); // fetch mySegments
+                        }
+                    });
+                    return;
+                }
+                case types_1.UpdateStrategy.KeyList: {
+                    var keyList = void 0, added_1, removed_1;
+                    try {
+                        keyList = mySegmentsV2utils_1.parseKeyList(parsedData.d, parsedData.c);
+                        added_1 = new sets_1._Set(keyList.a);
+                        removed_1 = new sets_1._Set(keyList.r);
+                    }
+                    catch (e) {
+                        log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
+                        break;
+                    }
+                    lang_1.forOwn(clients, function (_a) {
+                        var hash64 = _a.hash64, worker = _a.worker;
+                        var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
+                        if (add !== undefined) {
+                            worker.put(parsedData.changeNumber, {
+                                name: parsedData.segmentName,
+                                add: add
+                            });
+                        }
+                    });
+                    return;
+                }
+                case types_1.UpdateStrategy.SegmentRemoval:
+                    if (!parsedData.segmentName) {
+                        log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
+                        break;
+                    }
+                    lang_1.forOwn(clients, function (_a) {
+                        var worker = _a.worker;
+                        return worker.put(parsedData.changeNumber, {
+                            name: parsedData.segmentName,
+                            add: false
+                        });
+                    });
+                    return;
+            }
+            // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
+            lang_1.forOwn(clients, function (_a) {
+                var worker = _a.worker;
+                worker.put(parsedData.changeNumber);
+            });
+        });
     }
     else {
         pushEmitter.on(constants_1.SEGMENT_UPDATE, segmentsUpdateWorker.put);
@@ -159,13 +263,16 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
         // Expose functionality for starting and stoping push mode:
         stop: disconnectPush,
         start: function () {
+            // Guard condition to avoid calling `connectPush` again if the `start` method is called multiple times or if push has been disabled.
+            if (disabled || disconnected === false)
+                return;
+            disconnected = false;
             // Run in next event-loop cycle for optimization on client-side: if multiple clients are created in the same cycle than the factory, only one authentication is performed.
             setTimeout(connectPush);
         },
         // [Only for client-side]
         add: function (userKey, mySegmentsSyncTask) {
-            var mySegmentsUpdateWorker = new MySegmentsUpdateWorker_1.default(mySegmentsSyncTask);
-            workers[userKey] = mySegmentsUpdateWorker;
+            clients[userKey] = { hash64: murmur3_64_1.hash64(userKey), worker: new MySegmentsUpdateWorker_1.default(mySegmentsSyncTask) };
             var hash = AuthClient_1.hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
@@ -185,6 +292,7 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
         remove: function (userKey) {
             var hash = AuthClient_1.hashUserKey(userKey);
             delete userKeyHashes[hash];
+            delete clients[userKey];
         }
     });
 }

package/cjs/sync/submitters/metricsSyncTask.js

@@ -26,6 +26,6 @@ exports.countsSyncTaskFactory = countsSyncTaskFactory;
  */
 function latenciesSyncTaskFactory(log, postMetricsLatencies, latenciesCache, metricsRefreshRate, latencyTracker) {
     // don't retry metrics.
-    return submitterSyncTask_1.submitterSyncTaskFactory(log, postMetricsLatencies, latenciesCache, metricsRefreshRate, 'latency metrics', latencyTracker, fromCache('latencies'));
+    return submitterSyncTask_1.submitterSyncTaskFactory(log, postMetricsLatencies, latenciesCache, metricsRefreshRate, 'latency metrics', latencyTracker, fromCache('latencies'), 0, true);
 }
 exports.latenciesSyncTaskFactory = latenciesSyncTaskFactory;

package/cjs/sync/submitters/submitterSyncTask.js

@@ -7,7 +7,7 @@ var constants_1 = require("../../logger/constants");
 /**
  * Base function to create submitter sync tasks, such as ImpressionsSyncTask and EventsSyncTask
  */
-function submitterSyncTaskFactory(log, postClient, sourceCache, postRate, dataName, latencyTracker, fromCacheToPayload, maxRetries) {
+function submitterSyncTaskFactory(log, postClient, sourceCache, postRate, dataName, latencyTracker, fromCacheToPayload, maxRetries, debugLogs) {
     if (maxRetries === void 0) { maxRetries = 0; }
     var retries = 0;
     function postData() {
@@ -15,7 +15,7 @@ function submitterSyncTaskFactory(log, postClient, sourceCache, postRate, dataNa
             return Promise.resolve();
         var data = sourceCache.state();
         var dataCount = typeof data.length === 'number' ? data.length : '';
-        log.info(constants_1.SUBMITTERS_PUSH, [dataCount, dataName]);
+        log[debugLogs ? 'debug' : 'info'](constants_1.SUBMITTERS_PUSH, [dataCount, dataName]);
         var latencyTrackerStop = latencyTracker && latencyTracker.start();
         var jsonPayload = JSON.stringify(fromCacheToPayload ? fromCacheToPayload(data) : data);
         if (!maxRetries)

package/cjs/sync/syncManagerFromFile.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalhostFromFile = void 0;
+var splitsParserFromFile_1 = require("./offline/splitsParser/splitsParserFromFile");
+var syncManagerOffline_1 = require("./syncManagerOffline");
+var constants_1 = require("../utils/constants");
+// Factory of Localhost SyncManager based on yaml file.
+// Requires Node 'fs' and 'path' APIs.
+function LocalhostFromFile() {
+    var localhost = syncManagerOffline_1.syncManagerOfflineFactory(splitsParserFromFile_1.splitsParserFromFileFactory);
+    // @ts-ignore
+    localhost.type = constants_1.LOCALHOST_MODE;
+    return localhost;
+}
+exports.LocalhostFromFile = LocalhostFromFile;

package/cjs/sync/syncManagerFromObject.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalhostFromObject = void 0;
+var splitsParserFromSettings_1 = require("./offline/splitsParser/splitsParserFromSettings");
+var syncManagerOffline_1 = require("./syncManagerOffline");
+var constants_1 = require("../utils/constants");
+// Factory of Localhost SyncManager based on JS object.
+function LocalhostFromObject() {
+    var localhost = syncManagerOffline_1.syncManagerOfflineFactory(splitsParserFromSettings_1.splitsParserFromSettingsFactory);
+    // @ts-ignore
+    localhost.type = constants_1.LOCALHOST_MODE;
+    return localhost;
+}
+exports.LocalhostFromObject = LocalhostFromObject;

package/cjs/sync/syncManagerOffline.js

@@ -14,20 +14,20 @@ function flush() {
  *
  * @param splitsParser e.g., `splitsParserFromFile`, `splitsParserFromSettings`.
  */
-function syncManagerOfflineFactory(splitsParser) {
+function syncManagerOfflineFactory(splitsParserFactory) {
     /**
      * SyncManager factory for modular SDK
      */
     return function (_a) {
         var settings = _a.settings, readiness = _a.readiness, storage = _a.storage;
-        return object_assign_1.default(fromObjectSyncTask_1.default(splitsParser, storage, readiness, settings), {
+        return object_assign_1.default(fromObjectSyncTask_1.default(splitsParserFactory(), storage, readiness, settings), {
             // fake flush, that resolves immediately
             flush: flush,
             // [Only used for client-side]
             shared: function (matchingKey, readinessManager) {
                 return {
                     start: function () {
-                        // In LOCALHOST mode, shared clients are ready in the next event cycle than created
+                        // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
                         // SDK_READY cannot be emitted directly because this will not update the readiness status
                         setTimeout(function () {
                             readinessManager.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager

package/cjs/sync/syncManagerOnline.js

@@ -56,15 +56,25 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
             // fetch splits and segments. There is no need to catch this promise (it is always resolved)
             pollingManager.syncAll();
         }
-        var running = false;
+        if (pushManager) {
+            pushManager.on(constants_1.PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
+            pushManager.on(constants_1.PUSH_SUBSYSTEM_DOWN, startPolling);
+        }
+        var running = false; // flag that indicates whether the syncManager has been started (true) or stopped (false)
+        var startFirstTime = true; // flag to distinguish calling the `start` method for the first time, to support pausing and resuming the synchronization
         return {
+            pushManager: pushManager,
+            /**
+             * Method used to start the syncManager for the first time, or resume it after being stopped.
+             */
             start: function () {
                 // start syncing splits and segments
                 if (pushManager) {
-                    pollingManager.syncAll();
-                    pushManager.on(constants_1.PUSH_SUBSYSTEM_UP, stopPollingAndSyncAll);
-                    pushManager.on(constants_1.PUSH_SUBSYSTEM_DOWN, startPolling);
-                    // Run in next event-loop cycle as in client-side SyncManager
+                    // Doesn't call `syncAll` when the syncManager is resuming
+                    if (startFirstTime) {
+                        pollingManager.syncAll();
+                        startFirstTime = false;
+                    }
                     pushManager.start();
                 }
                 else {
@@ -74,6 +84,9 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                 submitter && submitter.start();
                 running = true;
             },
+            /**
+             * Method used to stop/pause the syncManager.
+             */
             stop: function () {
                 // stop syncing
                 if (pushManager)

package/cjs/sync/syncTask.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var constants_1 = require("../logger/constants");
 /**
- * Creates a syncTask that handles the periodic execution of a givan task ("start" and "stop" methods).
+ * Creates a syncTask that handles the periodic execution of a given task ("start" and "stop" methods).
  * The task can be executed once calling the "execute" method.
  * NOTE: Multiple calls to "execute" are not queued. Use "isExecuting" method to handle synchronization.
  *

package/cjs/trackers/impressionObserver/ImpressionObserver.js

@@ -8,8 +8,6 @@ var ImpressionObserver = /** @class */ (function () {
         this.hasher = hasher;
     }
     ImpressionObserver.prototype.testAndSet = function (impression) {
-        if (!impression)
-            return;
         var hash = this.hasher(impression);
         var previous = this.cache.get(hash);
         this.cache.set(hash, impression.time);

package/cjs/trackers/impressionObserver/buildKey.js

@@ -1,13 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var UNKNOWN = 'UNKNOWN';
-function _unknownIfNull(s) {
-    return s ? s : UNKNOWN;
-}
-function _zeroIfNull(l) {
-    return l ? l : 0;
-}
+exports.buildKey = void 0;
 function buildKey(impression) {
-    return _unknownIfNull(impression.keyName) + "\n    :" + _unknownIfNull(impression.feature) + "\n    :" + _unknownIfNull(impression.treatment) + "\n    :" + _unknownIfNull(impression.label) + "\n    :" + _zeroIfNull(impression.changeNumber);
+    return impression.keyName + ":" + impression.feature + ":" + impression.treatment + ":" + impression.label + ":" + impression.changeNumber;
 }
-exports.default = buildKey;
+exports.buildKey = buildKey;

package/cjs/trackers/impressionObserver/impressionObserverCS.js

@@ -4,9 +4,9 @@ exports.impressionObserverCSFactory = exports.hashImpression32 = void 0;
 var tslib_1 = require("tslib");
 var ImpressionObserver_1 = tslib_1.__importDefault(require("./ImpressionObserver"));
 var murmur3_1 = require("../../utils/murmur3/murmur3");
-var buildKey_1 = tslib_1.__importDefault(require("./buildKey"));
+var buildKey_1 = require("./buildKey");
 function hashImpression32(impression) {
-    return impression ? murmur3_1.hash(buildKey_1.default(impression)).toString() : null;
+    return murmur3_1.hash(buildKey_1.buildKey(impression));
 }
 exports.hashImpression32 = hashImpression32;
 var LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes