@splitsoftware/splitio-commons 1.2.1-rc.0 → 1.2.1-rc.11

package/esm/sdkClient/clientCS.js

@@ -17,6 +17,6 @@ export function clientCSDecorator(log, client, key, trafficType) {
         getTreatmentsWithConfig: clientCS.getTreatmentsWithConfig.bind(clientCS, key),
         // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
         track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
-        isBrowserClient: true
+        isClientSide: true
     });
 }

package/esm/sdkClient/clientInputValidation.js

@@ -2,12 +2,14 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
 import { CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
+import { isStorageSync } from '../trackers/impressionObserver/utils';
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export function clientInputValidationDecorator(log, client, readinessManager, isStorageSync) {
-    if (isStorageSync === void 0) { isStorageSync = false; }
+export function clientInputValidationDecorator(settings, client, readinessManager) {
+    var log = settings.log;
+    var isSync = isStorageSync(settings);
     /**
      * Avoid repeating this validations code
      */
@@ -27,9 +29,7 @@ export function clientInputValidationDecorator(log, client, readinessManager, is
         };
     }
     function wrapResult(value) {
-        if (isStorageSync)
-            return value;
-        return Promise.resolve(value);
+        return isSync ? value : Promise.resolve(value);
     }
     function getTreatment(maybeKey, maybeSplit, maybeAttributes) {
         var params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatment');
@@ -84,9 +84,7 @@ export function clientInputValidationDecorator(log, client, readinessManager, is
             return client.track(key, tt, event, eventValue, properties, size);
         }
         else {
-            if (isStorageSync)
-                return false;
-            return Promise.resolve(false);
+            return isSync ? false : Promise.resolve(false);
         }
     }
     return {

package/esm/sdkClient/sdkClient.js

@@ -1,5 +1,4 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../utils/constants';
 import { releaseApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
@@ -12,9 +11,7 @@ export function sdkClientFactory(params) {
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
     // Client API (getTreatment* & track methods)
-    clientInputValidationDecorator(settings.log, clientFactory(params), sdkReadinessManager.readinessManager, 
-    // storage is async if and only if mode is consumer or partial consumer
-    [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false), 
+    clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager), 
     // Sdk destroy
     {
         destroy: function () {

package/esm/sdkClient/sdkClientMethodCS.js

@@ -16,12 +16,8 @@ var method = 'Client instantiation';
  */
 export function sdkClientMethodCSFactory(params) {
     var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, readyTimeout = _a.startup.readyTimeout, log = _a.log;
-    // Keeping similar behaviour as in the isomorphic JS SDK: if settings key is invalid,
-    // `false` value is used as binded key of the default client, but trafficType is ignored
-    // @TODO handle as a non-recoverable error
-    var validKey = validateKey(log, key, method);
     var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), // @ts-ignore
-    validKey);
+    key);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
     // Cache instances created per factory.

package/esm/sdkClient/sdkClientMethodCSWithTT.js

@@ -18,16 +18,8 @@ var method = 'Client instantiation';
  */
 export function sdkClientMethodCSFactory(params) {
     var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, readyTimeout = _a.startup.readyTimeout, log = _a.log;
-    // Keeping the behaviour as in the isomorphic JS SDK: if settings key or TT are invalid,
-    // `false` value is used as binded key/TT of the default client, which leads to several issues.
-    // @TODO update when supporting non-recoverable errors
-    var validKey = validateKey(log, key, method);
-    var validTrafficType;
-    if (trafficType !== undefined) {
-        validTrafficType = validateTrafficType(log, trafficType, method);
-    }
     var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), // @ts-ignore
-    validKey, validTrafficType);
+    key, trafficType);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
     // Cache instances created per factory.

package/esm/sdkFactory/index.js

@@ -8,11 +8,12 @@ import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
 import { metadataBuilder } from '../storages/metadataBuilder';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
+import { objectAssign } from '../utils/lang/objectAssign';
 /**
  * Modular SDK factory
  */
 export function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, impressionListener = params.impressionListener, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory;
     var log = settings.log;
     // @TODO handle non-recoverable errors: not start sync, mark the SDK as destroyed, etc.
     // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
@@ -22,6 +23,7 @@ export function sdkFactory(params) {
     var readinessManager = sdkReadinessManager.readinessManager;
     // @TODO consider passing the settings object, so that each storage access only what it needs
     var storageFactoryParams = {
+        impressionsQueueSize: settings.scheduler.impressionsQueueSize,
         eventsQueueSize: settings.scheduler.eventsQueueSize,
         optimize: shouldBeOptimized(settings),
         // ATM, only used by InLocalStorage
@@ -54,8 +56,8 @@ export function sdkFactory(params) {
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage });
     // trackers
     var observer = impressionsObserverFactory && impressionsObserverFactory();
-    var impressionsTracker = impressionsTrackerFactory(log, storage.impressions, settings, impressionListener, integrationsManager, observer, storage.impressionCounts);
-    var eventTracker = eventTrackerFactory(log, storage.events, integrationsManager);
+    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts);
+    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager);
     // signal listener
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
     // Sdk client and manager
@@ -64,11 +66,11 @@ export function sdkFactory(params) {
     syncManager && syncManager.start();
     signalListener && signalListener.start();
     log.info(NEW_FACTORY);
-    return {
+    // @ts-ignore
+    return objectAssign({
         // Split evaluation and event tracking engine
         client: clientMethod,
         // Manager API to explore available information
-        // @ts-ignore
         manager: function () {
             log.debug(RETRIEVE_MANAGER);
             return managerInstance;
@@ -76,5 +78,5 @@ export function sdkFactory(params) {
         // Logger wrapper API
         Logger: createLoggerAPI(settings.log),
         settings: settings,
-    };
+    }, extraProps && extraProps(settings, syncManager));
 }

package/esm/sdkFactory/userConsentProps.js

@@ -0,0 +1,36 @@
+import { ERROR_NOT_BOOLEAN, USER_CONSENT_UPDATED, USER_CONSENT_NOT_UPDATED, USER_CONSENT_INITIAL } from '../logger/constants';
+import { isConsentGranted } from '../utils/consent';
+import { CONSENT_GRANTED, CONSENT_DECLINED } from '../utils/constants';
+import { isBoolean } from '../utils/lang';
+// Extend client-side factory instances with user consent getter/setter
+export function userConsentProps(settings, syncManager) {
+    var log = settings.log;
+    if (!isConsentGranted(settings))
+        log.info(USER_CONSENT_INITIAL, [settings.userConsent]);
+    return {
+        setUserConsent: function (consent) {
+            var _a, _b;
+            // validate input param
+            if (!isBoolean(consent)) {
+                log.warn(ERROR_NOT_BOOLEAN, ['setUserConsent']);
+                return false;
+            }
+            var newConsentStatus = consent ? CONSENT_GRANTED : CONSENT_DECLINED;
+            if (settings.userConsent !== newConsentStatus) {
+                log.info(USER_CONSENT_UPDATED, [settings.userConsent, newConsentStatus]); // @ts-ignore, modify readonly prop
+                settings.userConsent = newConsentStatus;
+                if (consent)
+                    (_a = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _a === void 0 ? void 0 : _a.start(); // resumes submitters if transitioning to GRANTED
+                else
+                    (_b = syncManager === null || syncManager === void 0 ? void 0 : syncManager.submitter) === null || _b === void 0 ? void 0 : _b.stop(); // pauses submitters if transitioning to DECLINED
+            }
+            else {
+                log.info(USER_CONSENT_NOT_UPDATED, [newConsentStatus]);
+            }
+            return true;
+        },
+        getUserConsent: function () {
+            return settings.userConsent;
+        }
+    };
+}

package/esm/services/splitApi.js

@@ -72,7 +72,8 @@ export function splitApiFactory(settings, platform) {
             return splitHttpClient(url, {
                 // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
                 method: 'POST',
-                body: body, headers: objectAssign({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
+                body: body,
+                headers: objectAssign({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
             });
         },
         /**

package/esm/storages/KeyBuilder.js

@@ -1,12 +1,8 @@
-import { endsWith, startsWith } from '../utils/lang';
+import { startsWith } from '../utils/lang';
 var everythingAtTheEnd = /[^.]+$/;
 var DEFAULT_PREFIX = 'SPLITIO';
 export function validatePrefix(prefix) {
-    return prefix && typeof prefix === 'string' ?
-        endsWith(prefix, '.' + DEFAULT_PREFIX) ?
-            prefix : // suffix already appended
-            prefix + '.' + DEFAULT_PREFIX : // append suffix
-        DEFAULT_PREFIX; // use default prefix if none is provided
+    return prefix ? prefix + '.SPLITIO' : 'SPLITIO';
 }
 var KeyBuilder = /** @class */ (function () {
     function KeyBuilder(prefix) {

package/esm/storages/KeyBuilderCS.js

@@ -13,9 +13,19 @@ var KeyBuilderCS = /** @class */ (function (_super) {
      * @override
      */
     KeyBuilderCS.prototype.buildSegmentNameKey = function (segmentName) {
-        return this.matchingKey + "." + this.prefix + ".segment." + segmentName;
+        return this.prefix + "." + this.matchingKey + ".segment." + segmentName;
     };
     KeyBuilderCS.prototype.extractSegmentName = function (builtSegmentKeyName) {
+        var prefix = this.prefix + "." + this.matchingKey + ".segment.";
+        if (startsWith(builtSegmentKeyName, prefix))
+            return builtSegmentKeyName.substr(prefix.length);
+    };
+    // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
+    KeyBuilderCS.prototype.buildOldSegmentNameKey = function (segmentName) {
+        return this.matchingKey + "." + this.prefix + ".segment." + segmentName;
+    };
+    // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
+    KeyBuilderCS.prototype.extractOldSegmentKey = function (builtSegmentKeyName) {
         var prefix = this.matchingKey + "." + this.prefix + ".segment.";
         if (startsWith(builtSegmentKeyName, prefix))
             return builtSegmentKeyName.substr(prefix.length);

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -57,9 +57,29 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         var index;
         // Scan current values from localStorage
         var storedSegmentNames = Object.keys(localStorage).reduce(function (accum, key) {
-            var name = _this.keys.extractSegmentName(key);
-            if (name)
-                accum.push(name);
+            var segmentName = _this.keys.extractSegmentName(key);
+            if (segmentName) {
+                accum.push(segmentName);
+            }
+            else {
+                // @BREAKING: This is only to clean up "old" keys. Remove this whole else code block.
+                segmentName = _this.keys.extractOldSegmentKey(key);
+                if (segmentName) { // this was an old segment key, let's clean up.
+                    var newSegmentKey = _this.keys.buildSegmentNameKey(segmentName);
+                    try {
+                        // If the new format key is not there, create it.
+                        if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
+                            localStorage.setItem(newSegmentKey, DEFINED);
+                            // we are migrating a segment, let's track it.
+                            accum.push(segmentName);
+                        }
+                        localStorage.removeItem(key); // we migrated the current key, let's delete it.
+                    }
+                    catch (e) {
+                        _this.log.error(e);
+                    }
+                }
+            }
             return accum;
         }, []);
         // Extreme fast => everything is empty

package/esm/storages/inLocalStorage/index.js

@@ -30,7 +30,7 @@ export function InLocalStorage(options) {
         return {
             splits: new SplitsCacheInLocal(log, keys, expirationTimestamp, params.splitFiltersValidation),
             segments: new MySegmentsCacheInLocal(log, keys),
-            impressions: new ImpressionsCacheInMemory(),
+            impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
             impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
             events: new EventsCacheInMemory(params.eventsQueueSize),
             destroy: function () {

package/esm/storages/inMemory/ImpressionsCacheInMemory.js

@@ -1,13 +1,27 @@
 var ImpressionsCacheInMemory = /** @class */ (function () {
-    function ImpressionsCacheInMemory() {
+    /**
+     *
+     * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+     * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+     */
+    function ImpressionsCacheInMemory(impressionsQueueSize) {
+        if (impressionsQueueSize === void 0) { impressionsQueueSize = 0; }
+        this.maxQueue = impressionsQueueSize;
         this.queue = [];
     }
+    ImpressionsCacheInMemory.prototype.setOnFullQueueCb = function (cb) {
+        this.onFullQueue = cb;
+    };
     /**
      * Store impressions in sequential order
      */
     ImpressionsCacheInMemory.prototype.track = function (data) {
         var _a;
         (_a = this.queue).push.apply(_a, data);
+        // Check if the cache queue is full and we need to flush it.
+        if (this.maxQueue > 0 && this.queue.length >= this.maxQueue && this.onFullQueue) {
+            this.onFullQueue();
+        }
     };
     /**
      * Clear the data stored on the cache.

package/esm/storages/inMemory/InMemoryStorage.js

@@ -13,7 +13,7 @@ export function InMemoryStorageFactory(params) {
     return {
         splits: new SplitsCacheInMemory(),
         segments: new SegmentsCacheInMemory(),
-        impressions: new ImpressionsCacheInMemory(),
+        impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
         impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory(params.eventsQueueSize),
         // When using MEMORY we should clean all the caches to leave them empty

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -13,7 +13,7 @@ export function InMemoryStorageCSFactory(params) {
     return {
         splits: new SplitsCacheInMemory(),
         segments: new MySegmentsCacheInMemory(),
-        impressions: new ImpressionsCacheInMemory(),
+        impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
         impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory(params.eventsQueueSize),
         // When using MEMORY we should clean all the caches to leave them empty

package/esm/storages/inRedis/RedisAdapter.js

@@ -143,15 +143,28 @@ var RedisAdapter = /** @class */ (function (_super) {
         else { // If it IS the string URL, that'll be the first param for ioredis.
             result.unshift(options.url);
         }
+        if (options.connectionTimeout) {
+            merge(opts, { connectTimeout: options.connectionTimeout });
+        }
+        if (options.tls) {
+            merge(opts, { tls: options.tls });
+        }
         return result;
     };
     /**
      * Parses the options into what we care about.
      */
     RedisAdapter._defineOptions = function (_a) {
-        var connectionTimeout = _a.connectionTimeout, operationTimeout = _a.operationTimeout, url = _a.url, host = _a.host, port = _a.port, db = _a.db, pass = _a.pass;
+        var connectionTimeout = _a.connectionTimeout, operationTimeout = _a.operationTimeout, url = _a.url, host = _a.host, port = _a.port, db = _a.db, pass = _a.pass, tls = _a.tls;
         var parsedOptions = {
-            connectionTimeout: connectionTimeout, operationTimeout: operationTimeout, url: url, host: host, port: port, db: db, pass: pass
+            connectionTimeout: connectionTimeout,
+            operationTimeout: operationTimeout,
+            url: url,
+            host: host,
+            port: port,
+            db: db,
+            pass: pass,
+            tls: tls
         };
         return merge({}, DEFAULT_OPTIONS, parsedOptions);
     };

package/esm/storages/pluggable/index.js

@@ -51,7 +51,7 @@ export function PluggableStorage(options) {
     validatePluggableStorageOptions(options);
     var prefix = validatePrefix(options.prefix);
     function PluggableStorageFactory(_a) {
-        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, mode = _a.mode, eventsQueueSize = _a.eventsQueueSize, optimize = _a.optimize;
+        var log = _a.log, metadata = _a.metadata, onReadyCb = _a.onReadyCb, mode = _a.mode, eventsQueueSize = _a.eventsQueueSize, impressionsQueueSize = _a.impressionsQueueSize, optimize = _a.optimize;
         var keys = new KeyBuilderSS(prefix, metadata);
         var wrapper = wrapperAdapter(log, options.wrapper);
         var isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
@@ -60,7 +60,7 @@ export function PluggableStorage(options) {
         return {
             splits: new SplitsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable(log, keys, wrapper),
-            impressions: isPartialConsumer ? new ImpressionsCacheInMemory() : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
+            impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
             impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
             // @TODO add telemetry cache when required

package/esm/sync/offline/splitsParser/splitsParserFromFile.js

@@ -62,7 +62,7 @@ export function splitsParserFromFileFactory() {
             data = fs.readFileSync(filePath, 'utf-8');
         }
         catch (e) {
-            log.error(e.message);
+            log.error(e && e.message);
             return {};
         }
         if (data === previousMock)

package/esm/sync/polling/fetchers/mySegmentsFetcher.js

@@ -2,8 +2,8 @@
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-export function mySegmentsFetcherFactory(fetchMySegments, userMatchingKey) {
-    return function mySegmentsFetcher(noCache, 
+export function mySegmentsFetcherFactory(fetchMySegments) {
+    return function mySegmentsFetcher(userMatchingKey, noCache, 
     // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator) {
         var mySegmentsPromise = fetchMySegments(userMatchingKey, noCache);

package/esm/sync/polling/fetchers/segmentChangesFetcher.js

@@ -1,4 +1,4 @@
-import { __spreadArrays } from "tslib";
+import { __spreadArray } from "tslib";
 function greedyFetch(fetchSegmentChanges, since, segmentName, noCache) {
     return fetchSegmentChanges(since, segmentName, noCache)
         .then(function (resp) { return resp.json(); })
@@ -9,7 +9,7 @@ function greedyFetch(fetchSegmentChanges, since, segmentName, noCache) {
         }
         else {
             return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache)]).then(function (flatMe) {
-                return __spreadArrays([flatMe[0]], flatMe[1]);
+                return __spreadArray([flatMe[0]], flatMe[1], true);
             });
         }
     });

package/esm/sync/polling/pollingManagerCS.js

@@ -8,7 +8,8 @@ import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-export function pollingManagerCSFactory(splitApi, storage, readiness, settings) {
+export function pollingManagerCSFactory(params) {
+    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
     // Map of matching keys to their corresponding MySegmentsSyncTask.

package/esm/sync/polling/pollingManagerSS.js

@@ -5,7 +5,8 @@ import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logg
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-export function pollingManagerSSFactory(splitApi, storage, readiness, settings) {
+export function pollingManagerSSFactory(params) {
+    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
     var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
     var segmentsSyncTask = segmentsSyncTaskFactory(splitApi.fetchSegmentChanges, storage, readiness, settings);

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

@@ -5,5 +5,5 @@ import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
 export function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {
-    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments, matchingKey), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
+    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
 }

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

@@ -7,7 +7,7 @@ import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady) {
+export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -51,7 +51,7 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
             // If segmentsData is provided, there is no need to fetch mySegments
             new Promise(function (res) { updateSegments(segmentsData); res(true); }) :
             // If not provided, fetch mySegments
-            mySegmentsFetcher(noCache, _promiseDecorator).then(function (segments) {
+            mySegmentsFetcher(matchingKey, noCache, _promiseDecorator).then(function (segments) {
                 // Only when we have downloaded segments completely, we should not keep retrying anymore
                 startingUp = false;
                 updateSegments(segments);

package/esm/sync/streaming/SSEClient/index.js

@@ -1,3 +1,4 @@
+import { isString } from '../../../utils/lang';
 var VERSION = '1.1';
 var CONTROL_CHANNEL_REGEX = /^control_/;
 /**
@@ -8,7 +9,7 @@ var CONTROL_CHANNEL_REGEX = /^control_/;
  */
 function buildSSEHeaders(settings) {
     var headers = {
-        SplitSDKClientKey: settings.core.authorizationKey.slice(-4),
+        SplitSDKClientKey: isString(settings.core.authorizationKey) ? settings.core.authorizationKey.slice(-4) : '',
         SplitSDKVersion: settings.version,
     };
     // ip and hostname are false if IPAddressesEnabled is false

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

@@ -7,7 +7,7 @@ var SegmentsUpdateWorker = /** @class */ (function () {
      * @param {Object} segmentsCache segments data cache
      * @param {Object} segmentsSyncTask task for syncing segments data
      */
-    function SegmentsUpdateWorker(segmentsCache, segmentsSyncTask) {
+    function SegmentsUpdateWorker(segmentsSyncTask, segmentsCache) {
         this.segmentsCache = segmentsCache;
         this.segmentsSyncTask = segmentsSyncTask;
         this.maxChangeNumbers = {};

package/esm/sync/streaming/pushManager.js

@@ -19,7 +19,8 @@ import { hash64 } from '../../utils/murmur3/murmur3_64';
  * - for server-side if key is not provided in settings.
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
-export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platform, settings) {
+export function pushManagerFactory(params, pollingManager) {
+    var settings = params.settings, storage = params.storage, splitApi = params.splitApi, readiness = params.readiness, platform = params.platform;
     // `userKey` is the matching key of main client in client-side SDK.
     // It can be used to check if running on client-side or server-side SDK.
     var userKey = settings.core.key ? getMatching(settings.core.key) : undefined;
@@ -33,14 +34,14 @@ export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth
         log.warn(STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = authenticateFactory(fetchAuth);
+    var authenticate = authenticateFactory(splitApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
     var sseHandler = SSEHandlerFactory(log, pushEmitter);
     sseClient.setEventHandler(sseHandler);
     // init workers
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
-    var segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(storage.segments, pollingManager.segmentsSyncTask);
+    var segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
     var splitsUpdateWorker = new SplitsUpdateWorker(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
@@ -54,6 +55,7 @@ export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth
     // 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.
+    // true if STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE or Auth errors.
     var disabled; // `disabled` implies `disconnected === true`
     /** PushManager functions related to initialization */
     var connectPushRetryBackoff = new Backoff(connectPush, settings.scheduler.pushRetryBackoffBase);
@@ -254,13 +256,15 @@ export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth
     return objectAssign(
     // Expose Event Emitter functionality and Event constants
     Object.create(pushEmitter), {
-        // Stop/pause push mode
+        // Stop/pause push mode.
+        // It doesn't emit events. Neither PUSH_SUBSYSTEM_DOWN to start polling.
         stop: function () {
             disconnectPush(); // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which starts polling.
             if (userKey)
                 this.remove(userKey); // Necessary to properly resume streaming in client-side (e.g., RN SDK transition to foreground).
         },
-        // Start/resume push mode
+        // Start/resume push mode.
+        // It eventually emits PUSH_SUBSYSTEM_DOWN, that starts polling, or PUSH_SUBSYSTEM_UP, that executes a syncAll
         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)
@@ -271,6 +275,10 @@ export function pushManagerFactory(pollingManager, storage, readiness, fetchAuth
             else
                 setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
         },
+        // true/false if start or stop was called last respectively
+        isRunning: function () {
+            return disconnected === false;
+        },
         // [Only for client-side]
         add: function (userKey, mySegmentsSyncTask) {
             var hash = hashUserKey(userKey);

package/esm/sync/submitters/eventsSyncTask.js

@@ -1,28 +1,40 @@
 import { submitterSyncTaskFactory } from './submitterSyncTask';
-import { SUBMITTERS_PUSH_FULL_EVENTS_QUEUE } from '../../logger/constants';
+import { SUBMITTERS_PUSH_FULL_QUEUE } from '../../logger/constants';
+var DATA_NAME = 'events';
 /**
  * Sync task that periodically posts tracked events
  */
 export function eventsSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, eventsFirstPushWindow, latencyTracker) {
     // don't retry events.
-    var syncTask = submitterSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, 'queued events', latencyTracker);
-    // Set a timer for the first push of events,
+    var syncTask = submitterSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, DATA_NAME, latencyTracker);
+    // Set a timer for the first push window of events.
+    // Not implemented in the base submitter or sync task, since this feature is only used by the events submitter.
     if (eventsFirstPushWindow > 0) {
+        var running_1 = false;
         var stopEventPublisherTimeout_1;
         var originalStart_1 = syncTask.start;
         syncTask.start = function () {
+            running_1 = true;
             stopEventPublisherTimeout_1 = setTimeout(originalStart_1, eventsFirstPushWindow);
         };
         var originalStop_1 = syncTask.stop;
         syncTask.stop = function () {
+            running_1 = false;
             clearTimeout(stopEventPublisherTimeout_1);
             originalStop_1();
         };
+        syncTask.isRunning = function () {
+            return running_1;
+        };
     }
-    // register eventsSubmitter to be executed when events cache is full
+    // register events submitter to be executed when events cache is full
     eventsCache.setOnFullQueueCb(function () {
-        log.info(SUBMITTERS_PUSH_FULL_EVENTS_QUEUE);
-        syncTask.execute();
+        if (syncTask.isRunning()) {
+            log.info(SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+            syncTask.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 syncTask;
 }