@splitsoftware/splitio-commons 3.1.1-rc.6 → 3.1.1-rc.7

package/CHANGES.txt

@@ -1,6 +1,5 @@
 3.2.0 (September 18, 2026)
  - Added support for AI configs.
- - Updated submitters to allow starting and executing them when the Configs SDK is ready.
  - Removed Configs SDK-related types and modules and moved them to the Configs SDK repository.
 
 3.1.0 (July 23, 2026)

package/cjs/sdkClient/sdkLifecycle.js

@@ -61,8 +61,9 @@ function sdkLifecycleFactory(params, isSharedClient) {
             }
             // Stop background jobs
             syncManager && syncManager.stop();
-            serviceApi && serviceApi.stop();
             return __flush().then(function () {
+                // Stop the service API (the auth provider backoff retries specifically) after the final flush, so it can still authenticate using the still-valid cached credential
+                serviceApi && serviceApi.stop();
                 // Cleanup storage
                 return storage.destroy();
             });

package/cjs/services/secureSplitHttpClient.js

@@ -10,18 +10,20 @@ var tslib_1 = require("tslib");
  * @param authProvider - `authProviderFactory` to use for authentication
  */
 function secureSplitHttpClientFactory(splitHttpClient, authProvider) {
-    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, token) {
-        return splitHttpClient(url, tslib_1.__assign(tslib_1.__assign({}, options), { headers: tslib_1.__assign(tslib_1.__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }), latencyTracker, logErrorsAsInfo, true);
+    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, token) {
+        return splitHttpClient(url, token ? tslib_1.__assign(tslib_1.__assign({}, options), { headers: tslib_1.__assign(tslib_1.__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }) : options, latencyTracker, logErrorsAsInfo, newVersionHeader);
     }
-    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo) {
+    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt) {
+        if (newVersionHeader === void 0) { newVersionHeader = true; }
+        if (useJwt === void 0) { useJwt = true; }
         return authProvider.credential().then(function (credential) {
-            return makeRequest(url, options, latencyTracker, logErrorsAsInfo, credential.token)
+            return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? credential.token : undefined)
                 .catch(function (error) {
                 if (error.statusCode === 401) {
                     // retry once for 401, in case the token has just expired
                     authProvider.invalidate();
                     return authProvider.credential().then(function (newCredential) {
-                        return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newCredential.token);
+                        return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? newCredential.token : undefined);
                     });
                 }
                 throw error;

package/cjs/services/serviceApi.js

@@ -84,7 +84,7 @@ function serviceApiFactory(settings, platform, telemetryTracker) {
          */
         postEventsBulk: function (body, headers) {
             var url = "".concat(urls.events, "/api/events/bulk");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.EVENTS));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.EVENTS), false, false, false);
         },
         /**
          * Post impressions.
@@ -94,12 +94,12 @@ function serviceApiFactory(settings, platform, telemetryTracker) {
          */
         postTestImpressionsBulk: function (body, headers) {
             var url = "".concat(urls.events, "/api/testImpressions/bulk");
-            return splitHttpClient(url, {
+            return secureSplitHttpClient(url, {
                 // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
                 method: 'POST',
                 body: body,
                 headers: (0, objectAssign_1.objectAssign)({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
-            }, telemetryTracker.trackHttp(constants_1.IMPRESSIONS));
+            }, telemetryTracker.trackHttp(constants_1.IMPRESSIONS), false, false, false);
         },
         /**
          * Post impressions counts.
@@ -109,7 +109,7 @@ function serviceApiFactory(settings, platform, telemetryTracker) {
          */
         postTestImpressionsCount: function (body, headers) {
             var url = "".concat(urls.events, "/api/testImpressions/count");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.IMPRESSIONS_COUNT));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.IMPRESSIONS_COUNT), false, false, false);
         },
         /**
          * Post unique keys for client side.
@@ -119,7 +119,7 @@ function serviceApiFactory(settings, platform, telemetryTracker) {
          */
         postUniqueKeysBulkCs: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/keys/cs");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), false, false, false);
         },
         /**
          * Post unique keys for server side.
@@ -129,7 +129,7 @@ function serviceApiFactory(settings, platform, telemetryTracker) {
          */
         postUniqueKeysBulkSs: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/keys/ss");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), false, false, false);
         },
         postMetricsConfig: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/metrics/config");

package/cjs/sync/submitters/submitterManager.js

@@ -6,64 +6,41 @@ var impressionsSubmitter_1 = require("./impressionsSubmitter");
 var impressionCountsSubmitter_1 = require("./impressionCountsSubmitter");
 var telemetrySubmitter_1 = require("./telemetrySubmitter");
 var uniqueKeysSubmitter_1 = require("./uniqueKeysSubmitter");
-var constants_1 = require("../../readiness/constants");
-/**
- * Creates a submitter manager.
- *
- * @param startWhenReady - If true, the submitters will only start and execute the underlying submitters when the SDK is ready.
- * `true` for Configs SDK, `false` for Flags SDKs.
- */
-function submitterManagerFactory(startWhenReady) {
-    return function (params) {
-        var readiness = params.readiness;
-        var submitters = [
-            (0, impressionsSubmitter_1.impressionsSubmitterFactory)(params),
-            (0, eventsSubmitter_1.eventsSubmitterFactory)(params),
-            (0, impressionCountsSubmitter_1.impressionCountsSubmitterFactory)(params),
-            (0, uniqueKeysSubmitter_1.uniqueKeysSubmitterFactory)(params)
-        ];
-        var telemetrySubmitter = (0, telemetrySubmitter_1.telemetrySubmitterFactory)(params);
-        var isRunning = false;
-        function startSubmitters(onlyTelemetry) {
-            if (!isRunning)
-                return;
+function submitterManagerFactory(params) {
+    var submitters = [
+        (0, impressionsSubmitter_1.impressionsSubmitterFactory)(params),
+        (0, eventsSubmitter_1.eventsSubmitterFactory)(params),
+        (0, impressionCountsSubmitter_1.impressionCountsSubmitterFactory)(params),
+        (0, uniqueKeysSubmitter_1.uniqueKeysSubmitterFactory)(params)
+    ];
+    var telemetrySubmitter = (0, telemetrySubmitter_1.telemetrySubmitterFactory)(params);
+    return {
+        // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
+        start: function (onlyTelemetry) {
             if (!onlyTelemetry)
                 submitters.forEach(function (submitter) { return submitter.start(); });
             if (telemetrySubmitter)
                 telemetrySubmitter.start();
+        },
+        // `allExceptTelemetry` true if userConsent is changed to DECLINED
+        stop: function (allExceptTelemetry) {
+            submitters.forEach(function (submitter) { return submitter.stop(); });
+            if (!allExceptTelemetry && telemetrySubmitter)
+                telemetrySubmitter.stop();
+        },
+        isRunning: function () {
+            return submitters.some(function (submitter) { return submitter.isRunning(); });
+        },
+        // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
+        execute: function (onlyTelemetry) {
+            var promises = onlyTelemetry ? [] : submitters.map(function (submitter) { return submitter.execute(); });
+            if (telemetrySubmitter)
+                promises.push(telemetrySubmitter.execute());
+            return Promise.all(promises).then(function () { });
+        },
+        isExecuting: function () {
+            return submitters.some(function (submitter) { return submitter.isExecuting(); });
         }
-        return {
-            // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
-            start: function (onlyTelemetry) {
-                isRunning = true;
-                if (!startWhenReady || readiness.isReady())
-                    startSubmitters(onlyTelemetry);
-                else
-                    readiness.gate.once(constants_1.SDK_READY, function () { return startSubmitters(onlyTelemetry); });
-            },
-            // `allExceptTelemetry` true if userConsent is changed to DECLINED
-            stop: function (allExceptTelemetry) {
-                isRunning = false;
-                submitters.forEach(function (submitter) { return submitter.stop(); });
-                if (!allExceptTelemetry && telemetrySubmitter)
-                    telemetrySubmitter.stop();
-            },
-            isRunning: function () {
-                return isRunning;
-            },
-            // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
-            execute: function (onlyTelemetry) {
-                if (startWhenReady && !readiness.isReady())
-                    return Promise.resolve();
-                var promises = onlyTelemetry ? [] : submitters.map(function (submitter) { return submitter.execute(); });
-                if (telemetrySubmitter)
-                    promises.push(telemetrySubmitter.execute());
-                return Promise.all(promises).then(function () { });
-            },
-            isExecuting: function () {
-                return submitters.some(function (submitter) { return submitter.isExecuting(); });
-            }
-        };
     };
 }
 exports.submitterManagerFactory = submitterManagerFactory;

package/cjs/sync/syncManagerOnline.js

@@ -15,10 +15,8 @@ var AbstractDefinitionsCacheSync_1 = require("../storages/AbstractDefinitionsCac
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
- * @param submitterManagerFactory - specify the submitter manager factory to use
  */
-function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, _submitterManagerFactory) {
-    if (_submitterManagerFactory === void 0) { _submitterManagerFactory = (0, submitterManager_1.submitterManagerFactory)(); }
+function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
     /**
      * SyncManager factory for modular SDK
      */
@@ -32,7 +30,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, _su
             undefined;
         /** Submitter Manager */
         // It is not injected as push and polling managers, because at the moment it is required
-        var submitterManager = _submitterManagerFactory(params);
+        var submitterManager = (0, submitterManager_1.submitterManagerFactory)(params);
         /** Sync Manager logic */
         function startPolling() {
             if (pollingManager.isRunning()) {

package/esm/sdkClient/sdkLifecycle.js

@@ -58,8 +58,9 @@ export function sdkLifecycleFactory(params, isSharedClient) {
             }
             // Stop background jobs
             syncManager && syncManager.stop();
-            serviceApi && serviceApi.stop();
             return __flush().then(function () {
+                // Stop the service API (the auth provider backoff retries specifically) after the final flush, so it can still authenticate using the still-valid cached credential
+                serviceApi && serviceApi.stop();
                 // Cleanup storage
                 return storage.destroy();
             });

package/esm/services/secureSplitHttpClient.js

@@ -7,18 +7,20 @@ import { __assign } from "tslib";
  * @param authProvider - `authProviderFactory` to use for authentication
  */
 export function secureSplitHttpClientFactory(splitHttpClient, authProvider) {
-    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, token) {
-        return splitHttpClient(url, __assign(__assign({}, options), { headers: __assign(__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }), latencyTracker, logErrorsAsInfo, true);
+    function makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, token) {
+        return splitHttpClient(url, token ? __assign(__assign({}, options), { headers: __assign(__assign({}, options === null || options === void 0 ? void 0 : options.headers), { Authorization: "Bearer ".concat(token) }) }) : options, latencyTracker, logErrorsAsInfo, newVersionHeader);
     }
-    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo) {
+    var httpClient = function (url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt) {
+        if (newVersionHeader === void 0) { newVersionHeader = true; }
+        if (useJwt === void 0) { useJwt = true; }
         return authProvider.credential().then(function (credential) {
-            return makeRequest(url, options, latencyTracker, logErrorsAsInfo, credential.token)
+            return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? credential.token : undefined)
                 .catch(function (error) {
                 if (error.statusCode === 401) {
                     // retry once for 401, in case the token has just expired
                     authProvider.invalidate();
                     return authProvider.credential().then(function (newCredential) {
-                        return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newCredential.token);
+                        return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? newCredential.token : undefined);
                     });
                 }
                 throw error;

package/esm/services/serviceApi.js

@@ -81,7 +81,7 @@ export function serviceApiFactory(settings, platform, telemetryTracker) {
          */
         postEventsBulk: function (body, headers) {
             var url = "".concat(urls.events, "/api/events/bulk");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(EVENTS));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(EVENTS), false, false, false);
         },
         /**
          * Post impressions.
@@ -91,12 +91,12 @@ export function serviceApiFactory(settings, platform, telemetryTracker) {
          */
         postTestImpressionsBulk: function (body, headers) {
             var url = "".concat(urls.events, "/api/testImpressions/bulk");
-            return splitHttpClient(url, {
+            return secureSplitHttpClient(url, {
                 // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
                 method: 'POST',
                 body: body,
                 headers: objectAssign({ SplitSDKImpressionsMode: SplitSDKImpressionsMode }, headers)
-            }, telemetryTracker.trackHttp(IMPRESSIONS));
+            }, telemetryTracker.trackHttp(IMPRESSIONS), false, false, false);
         },
         /**
          * Post impressions counts.
@@ -106,7 +106,7 @@ export function serviceApiFactory(settings, platform, telemetryTracker) {
          */
         postTestImpressionsCount: function (body, headers) {
             var url = "".concat(urls.events, "/api/testImpressions/count");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT), false, false, false);
         },
         /**
          * Post unique keys for client side.
@@ -116,7 +116,7 @@ export function serviceApiFactory(settings, platform, telemetryTracker) {
          */
         postUniqueKeysBulkCs: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/keys/cs");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), false, false, false);
         },
         /**
          * Post unique keys for server side.
@@ -126,7 +126,7 @@ export function serviceApiFactory(settings, platform, telemetryTracker) {
          */
         postUniqueKeysBulkSs: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/keys/ss");
-            return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
+            return secureSplitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), false, false, false);
         },
         postMetricsConfig: function (body, headers) {
             var url = "".concat(urls.telemetry, "/api/v1/metrics/config");

package/esm/sync/submitters/submitterManager.js

@@ -3,63 +3,40 @@ import { impressionsSubmitterFactory } from './impressionsSubmitter';
 import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
 import { telemetrySubmitterFactory } from './telemetrySubmitter';
 import { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';
-import { SDK_READY } from '../../readiness/constants';
-/**
- * Creates a submitter manager.
- *
- * @param startWhenReady - If true, the submitters will only start and execute the underlying submitters when the SDK is ready.
- * `true` for Configs SDK, `false` for Flags SDKs.
- */
-export function submitterManagerFactory(startWhenReady) {
-    return function (params) {
-        var readiness = params.readiness;
-        var submitters = [
-            impressionsSubmitterFactory(params),
-            eventsSubmitterFactory(params),
-            impressionCountsSubmitterFactory(params),
-            uniqueKeysSubmitterFactory(params)
-        ];
-        var telemetrySubmitter = telemetrySubmitterFactory(params);
-        var isRunning = false;
-        function startSubmitters(onlyTelemetry) {
-            if (!isRunning)
-                return;
+export function submitterManagerFactory(params) {
+    var submitters = [
+        impressionsSubmitterFactory(params),
+        eventsSubmitterFactory(params),
+        impressionCountsSubmitterFactory(params),
+        uniqueKeysSubmitterFactory(params)
+    ];
+    var telemetrySubmitter = telemetrySubmitterFactory(params);
+    return {
+        // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
+        start: function (onlyTelemetry) {
             if (!onlyTelemetry)
                 submitters.forEach(function (submitter) { return submitter.start(); });
             if (telemetrySubmitter)
                 telemetrySubmitter.start();
+        },
+        // `allExceptTelemetry` true if userConsent is changed to DECLINED
+        stop: function (allExceptTelemetry) {
+            submitters.forEach(function (submitter) { return submitter.stop(); });
+            if (!allExceptTelemetry && telemetrySubmitter)
+                telemetrySubmitter.stop();
+        },
+        isRunning: function () {
+            return submitters.some(function (submitter) { return submitter.isRunning(); });
+        },
+        // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
+        execute: function (onlyTelemetry) {
+            var promises = onlyTelemetry ? [] : submitters.map(function (submitter) { return submitter.execute(); });
+            if (telemetrySubmitter)
+                promises.push(telemetrySubmitter.execute());
+            return Promise.all(promises).then(function () { });
+        },
+        isExecuting: function () {
+            return submitters.some(function (submitter) { return submitter.isExecuting(); });
         }
-        return {
-            // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
-            start: function (onlyTelemetry) {
-                isRunning = true;
-                if (!startWhenReady || readiness.isReady())
-                    startSubmitters(onlyTelemetry);
-                else
-                    readiness.gate.once(SDK_READY, function () { return startSubmitters(onlyTelemetry); });
-            },
-            // `allExceptTelemetry` true if userConsent is changed to DECLINED
-            stop: function (allExceptTelemetry) {
-                isRunning = false;
-                submitters.forEach(function (submitter) { return submitter.stop(); });
-                if (!allExceptTelemetry && telemetrySubmitter)
-                    telemetrySubmitter.stop();
-            },
-            isRunning: function () {
-                return isRunning;
-            },
-            // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
-            execute: function (onlyTelemetry) {
-                if (startWhenReady && !readiness.isReady())
-                    return Promise.resolve();
-                var promises = onlyTelemetry ? [] : submitters.map(function (submitter) { return submitter.execute(); });
-                if (telemetrySubmitter)
-                    promises.push(telemetrySubmitter.execute());
-                return Promise.all(promises).then(function () { });
-            },
-            isExecuting: function () {
-                return submitters.some(function (submitter) { return submitter.isExecuting(); });
-            }
-        };
     };
 }

package/esm/sync/syncManagerOnline.js

@@ -12,10 +12,8 @@ import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
- * @param submitterManagerFactory - specify the submitter manager factory to use
  */
-export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory, _submitterManagerFactory) {
-    if (_submitterManagerFactory === void 0) { _submitterManagerFactory = submitterManagerFactory(); }
+export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
     /**
      * SyncManager factory for modular SDK
      */
@@ -29,7 +27,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
             undefined;
         /** Submitter Manager */
         // It is not injected as push and polling managers, because at the moment it is required
-        var submitterManager = _submitterManagerFactory(params);
+        var submitterManager = submitterManagerFactory(params);
         /** Sync Manager logic */
         function startPolling() {
             if (pollingManager.isRunning()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "3.1.1-rc.6",
+  "version": "3.1.1-rc.7",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/sdkClient/sdkLifecycle.ts

@@ -69,9 +69,10 @@ export function sdkLifecycleFactory(params: ISdkFactoryContext, isSharedClient?:
 
       // Stop background jobs
       syncManager && syncManager.stop();
-      serviceApi && serviceApi.stop();
 
       return __flush().then(() => {
+        // Stop the service API (the auth provider backoff retries specifically) after the final flush, so it can still authenticate using the still-valid cached credential
+        serviceApi && serviceApi.stop();
         // Cleanup storage
         return storage.destroy();
       });

package/src/services/secureSplitHttpClient.ts

@@ -10,19 +10,19 @@ import { IAuthProvider } from './authProvider';
  */
 export function secureSplitHttpClientFactory(splitHttpClient: ISplitHttpClient, authProvider: IAuthProvider): ISecureSplitHttpClient {
 
-  function makeRequest(url: string, options: IRequestOptions | undefined, latencyTracker: ((error?: NetworkError) => void) | undefined, logErrorsAsInfo: boolean | undefined, token: string): Promise<IResponse> {
-    return splitHttpClient(url, { ...options, headers: { ...options?.headers, Authorization: `Bearer ${token}` } }, latencyTracker, logErrorsAsInfo, true);
+  function makeRequest(url: string, options: IRequestOptions | undefined, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean, newVersionHeader?: boolean, token?: string): Promise<IResponse> {
+    return splitHttpClient(url, token ? { ...options, headers: { ...options?.headers, Authorization: `Bearer ${token}` } } : options, latencyTracker, logErrorsAsInfo, newVersionHeader);
   }
 
-  const httpClient = function (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean): Promise<IResponse> {
+  const httpClient = function (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean, newVersionHeader = true, useJwt = true): Promise<IResponse> {
     return authProvider.credential().then(credential => {
-      return makeRequest(url, options, latencyTracker, logErrorsAsInfo, credential.token)
+      return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? credential.token : undefined)
         .catch((error: NetworkError) => {
           if (error.statusCode === 401) {
             // retry once for 401, in case the token has just expired
             authProvider.invalidate();
             return authProvider.credential().then(newCredential => {
-              return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newCredential.token);
+              return makeRequest(url, options, latencyTracker, logErrorsAsInfo, newVersionHeader, useJwt ? newCredential.token : undefined);
             });
           }
           throw error;

package/src/services/serviceApi.ts

@@ -102,7 +102,7 @@ export function serviceApiFactory(
      */
     postEventsBulk(body: string, headers?: Record<string, string>) {
       const url = `${urls.events}/api/events/bulk`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(EVENTS));
+      return secureSplitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(EVENTS), false, false, false);
     },
 
     /**
@@ -113,10 +113,10 @@ export function serviceApiFactory(
      */
     postTestImpressionsBulk(body: string, headers?: Record<string, string>) {
       const url = `${urls.events}/api/testImpressions/bulk`;
-      return splitHttpClient(url, {
+      return secureSplitHttpClient(url, {
         // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
         method: 'POST', body, headers: objectAssign({ SplitSDKImpressionsMode }, headers)
-      }, telemetryTracker.trackHttp(IMPRESSIONS));
+      }, telemetryTracker.trackHttp(IMPRESSIONS), false, false, false);
     },
 
     /**
@@ -127,7 +127,7 @@ export function serviceApiFactory(
      */
     postTestImpressionsCount(body: string, headers?: Record<string, string>) {
       const url = `${urls.events}/api/testImpressions/count`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
+      return secureSplitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT), false, false, false);
     },
 
     /**
@@ -138,7 +138,7 @@ export function serviceApiFactory(
      */
     postUniqueKeysBulkCs(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/api/v1/keys/cs`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
+      return secureSplitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), false, false, false);
     },
 
     /**
@@ -149,7 +149,7 @@ export function serviceApiFactory(
      */
     postUniqueKeysBulkSs(body: string, headers?: Record<string, string>) {
       const url = `${urls.telemetry}/api/v1/keys/ss`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
+      return secureSplitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY), false, false, false);
     },
 
     postMetricsConfig(body: string, headers?: Record<string, string>) {

package/src/services/types.ts

@@ -35,7 +35,7 @@ export type IHealthCheckAPI = () => Promise<boolean>
 
 export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean, newVersionHeader?: boolean) => Promise<IResponse>
 
-export type ISecureSplitHttpClient = ISplitHttpClient & { stop(): void }
+export type ISecureSplitHttpClient = ((url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean, newVersionHeader?: boolean, useJwt?: boolean) => Promise<IResponse>) & { stop(): void }
 
 export type IFetchDefinitionChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
 
@@ -73,7 +73,7 @@ export interface IServiceApi {
 	postTestImpressionsCount: IPostTestImpressionsCount
 	postMetricsConfig: IPostMetricsConfig
 	postMetricsUsage: IPostMetricsUsage
-	// lifecycle
+	// lifecycle: stops authProvider backoff retries
 	stop(): void
 }
 

package/src/sync/submitters/submitterManager.ts

@@ -5,70 +5,44 @@ import { telemetrySubmitterFactory } from './telemetrySubmitter';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 import { ISubmitterManager } from './types';
 import { uniqueKeysSubmitterFactory } from './uniqueKeysSubmitter';
-import { SDK_READY } from '../../readiness/constants';
 
-/**
- * Creates a submitter manager.
- *
- * @param startWhenReady - If true, the submitters will only start and execute the underlying submitters when the SDK is ready.
- * `true` for Configs SDK, `false` for Flags SDKs.
- */
-export function submitterManagerFactory(startWhenReady?: boolean) {
+export function submitterManagerFactory(params: ISdkFactoryContextSync): ISubmitterManager {
 
-  return function (params: ISdkFactoryContextSync): ISubmitterManager {
+  const submitters = [
+    impressionsSubmitterFactory(params),
+    eventsSubmitterFactory(params),
+    impressionCountsSubmitterFactory(params),
+    uniqueKeysSubmitterFactory(params)
+  ];
 
-    const { readiness } = params;
-
-    const submitters = [
-      impressionsSubmitterFactory(params),
-      eventsSubmitterFactory(params),
-      impressionCountsSubmitterFactory(params),
-      uniqueKeysSubmitterFactory(params)
-    ];
-
-    const telemetrySubmitter = telemetrySubmitterFactory(params);
-    let isRunning = false;
-
-    function startSubmitters(onlyTelemetry?: boolean) {
-      if (!isRunning) return;
+  const telemetrySubmitter = telemetrySubmitterFactory(params);
 
+  return {
+    // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
+    start(onlyTelemetry?: boolean) {
       if (!onlyTelemetry) submitters.forEach(submitter => submitter.start());
       if (telemetrySubmitter) telemetrySubmitter.start();
+    },
+
+    // `allExceptTelemetry` true if userConsent is changed to DECLINED
+    stop(allExceptTelemetry?: boolean) {
+      submitters.forEach(submitter => submitter.stop());
+      if (!allExceptTelemetry && telemetrySubmitter) telemetrySubmitter.stop();
+    },
+
+    isRunning() {
+      return submitters.some(submitter => submitter.isRunning());
+    },
+
+    // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
+    execute(onlyTelemetry?: boolean) {
+      const promises = onlyTelemetry ? [] : submitters.map(submitter => submitter.execute());
+      if (telemetrySubmitter) promises.push(telemetrySubmitter.execute());
+      return Promise.all(promises).then(() => { });
+    },
+
+    isExecuting() {
+      return submitters.some(submitter => submitter.isExecuting());
     }
-
-    return {
-      // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
-      start(onlyTelemetry?: boolean) {
-        isRunning = true;
-
-        if (!startWhenReady || readiness.isReady()) startSubmitters(onlyTelemetry);
-        else readiness.gate.once(SDK_READY, () => startSubmitters(onlyTelemetry));
-      },
-
-      // `allExceptTelemetry` true if userConsent is changed to DECLINED
-      stop(allExceptTelemetry?: boolean) {
-        isRunning = false;
-
-        submitters.forEach(submitter => submitter.stop());
-        if (!allExceptTelemetry && telemetrySubmitter) telemetrySubmitter.stop();
-      },
-
-      isRunning() {
-        return isRunning;
-      },
-
-      // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
-      execute(onlyTelemetry?: boolean) {
-        if (startWhenReady && !readiness.isReady()) return Promise.resolve();
-
-        const promises = onlyTelemetry ? [] : submitters.map(submitter => submitter.execute());
-        if (telemetrySubmitter) promises.push(telemetrySubmitter.execute());
-        return Promise.all(promises).then(() => { });
-      },
-
-      isExecuting() {
-        return submitters.some(submitter => submitter.isExecuting());
-      }
-    };
   };
 }

package/src/sync/syncManagerOnline.ts

@@ -19,12 +19,10 @@ import { usesSegmentsSync } from '../storages/AbstractDefinitionsCacheSync';
  * @param pollingManagerFactory - allows to specialize the SyncManager for server-side or client-side API by passing
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory - optional to build a SyncManager with or without streaming support
- * @param submitterManagerFactory - specify the submitter manager factory to use
  */
 export function syncManagerOnlineFactory(
   pollingManagerFactory?: (params: ISdkFactoryContextSync) => IPollingManager,
   pushManagerFactory?: (params: ISdkFactoryContextSync, pollingManager: IPollingManager) => IPushManager | undefined,
-  _submitterManagerFactory = submitterManagerFactory(),
 ): (params: ISdkFactoryContextSync) => ISyncManagerCS {
 
   /**
@@ -44,7 +42,7 @@ export function syncManagerOnlineFactory(
 
     /** Submitter Manager */
     // It is not injected as push and polling managers, because at the moment it is required
-    const submitterManager = _submitterManagerFactory(params);
+    const submitterManager = submitterManagerFactory(params);
 
     /** Sync Manager logic */