@splitsoftware/splitio-commons 3.1.1-rc.0 → 3.1.1-rc.10

package/cjs/readiness/readinessManager.js

@@ -3,20 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readinessManagerFactory = void 0;
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_1 = require("./constants");
-function definitionsEventEmitterFactory(EventEmitter) {
-    var definitionsEventEmitter = (0, objectAssign_1.objectAssign)(new EventEmitter(), {
-        definitionsArrived: false,
-        definitionsCacheLoaded: false,
+function splitsEventEmitterFactory(EventEmitter) {
+    var splitsEventEmitter = (0, objectAssign_1.objectAssign)(new EventEmitter(), {
+        splitsArrived: false,
+        splitsCacheLoaded: false,
         hasInit: false,
         initCallbacks: []
     });
     // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
     // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
     // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
-    definitionsEventEmitter.on(constants_1.SDK_DEFINITIONS_ARRIVED, function (metadata, isSplitKill) { if (!isSplitKill)
-        definitionsEventEmitter.definitionsArrived = true; });
-    definitionsEventEmitter.once(constants_1.SDK_DEFINITIONS_CACHE_LOADED, function () { definitionsEventEmitter.definitionsCacheLoaded = true; });
-    return definitionsEventEmitter;
+    splitsEventEmitter.on(constants_1.SDK_SPLITS_ARRIVED, function (metadata, isSplitKill) { if (!isSplitKill)
+        splitsEventEmitter.splitsArrived = true; });
+    splitsEventEmitter.once(constants_1.SDK_SPLITS_CACHE_LOADED, function () { splitsEventEmitter.splitsCacheLoaded = true; });
+    return splitsEventEmitter;
 }
 function segmentsEventEmitterFactory(EventEmitter) {
     var segmentsEventEmitter = (0, objectAssign_1.objectAssign)(new EventEmitter(), {
@@ -28,8 +28,8 @@ function segmentsEventEmitterFactory(EventEmitter) {
 /**
  * Factory of readiness manager, which handles the ready / update event propagation.
  */
-function readinessManagerFactory(EventEmitter, settings, definitions, isShared) {
-    if (definitions === void 0) { definitions = definitionsEventEmitterFactory(EventEmitter); }
+function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
+    if (splits === void 0) { splits = splitsEventEmitterFactory(EventEmitter); }
     var readyTimeout = settings.startup.readyTimeout;
     var segments = segmentsEventEmitterFactory(EventEmitter);
     var gate = new EventEmitter();
@@ -44,10 +44,10 @@ function readinessManagerFactory(EventEmitter, settings, definitions, isShared)
     };
     // emit SDK_READY_FROM_CACHE
     var isReadyFromCache = false;
-    if (definitions.definitionsCacheLoaded)
+    if (splits.splitsCacheLoaded)
         isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
     else
-        definitions.once(constants_1.SDK_DEFINITIONS_CACHE_LOADED, checkIsReadyFromCache);
+        splits.once(constants_1.SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
     // emit SDK_READY_TIMED_OUT
     var hasTimedout = false;
     function timeout() {
@@ -55,11 +55,11 @@ function readinessManagerFactory(EventEmitter, settings, definitions, isShared)
             return;
         hasTimedout = true;
         syncLastUpdate();
-        gate.emit(constants_1.SDK_READY_TIMED_OUT, 'SDK client emitted SDK_READY_TIMED_OUT event.');
+        gate.emit(constants_1.SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
     }
     // emit SDK_READY and SDK_UPDATE
     var isReady = false;
-    definitions.on(constants_1.SDK_DEFINITIONS_ARRIVED, checkIsReadyOrUpdate);
+    splits.on(constants_1.SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
     segments.on(constants_1.SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
     var isDestroyed = false;
     var readyTimeoutId;
@@ -68,8 +68,8 @@ function readinessManagerFactory(EventEmitter, settings, definitions, isShared)
         if (readyTimeout > 0 && !isReady)
             readyTimeoutId = setTimeout(timeout, readyTimeout);
     }
-    definitions.initCallbacks.push(__init);
-    if (definitions.hasInit)
+    splits.initCallbacks.push(__init);
+    if (splits.hasInit)
         __init();
     function checkIsReadyFromCache(cacheMetadata) {
         metadataReady = cacheMetadata;
@@ -100,7 +100,7 @@ function readinessManagerFactory(EventEmitter, settings, definitions, isShared)
             }
         }
         else {
-            if (definitions.definitionsArrived && segments.segmentsArrived) {
+            if (splits.splitsArrived && segments.segmentsArrived) {
                 clearTimeout(readyTimeoutId);
                 isReady = true;
                 try {
@@ -123,11 +123,11 @@ function readinessManagerFactory(EventEmitter, settings, definitions, isShared)
         }
     }
     return {
-        definitions: definitions,
+        splits: splits,
         segments: segments,
         gate: gate,
         shared: function () {
-            return readinessManagerFactory(EventEmitter, settings, definitions, true);
+            return readinessManagerFactory(EventEmitter, settings, splits, true);
         },
         // @TODO review/remove next methods when non-recoverable errors are reworked
         // Called on consumer mode, when storage fails to connect
@@ -136,17 +136,17 @@ function readinessManagerFactory(EventEmitter, settings, definitions, isShared)
         // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
         setDestroyed: function () { isDestroyed = true; },
         init: function () {
-            if (definitions.hasInit)
+            if (splits.hasInit)
                 return;
-            definitions.hasInit = true;
-            definitions.initCallbacks.forEach(function (cb) { return cb(); });
+            splits.hasInit = true;
+            splits.initCallbacks.forEach(function (cb) { return cb(); });
         },
         destroy: function () {
             isDestroyed = true;
             syncLastUpdate();
             clearTimeout(readyTimeoutId);
             if (!isShared)
-                definitions.hasInit = false;
+                splits.hasInit = false;
         },
         isReady: function () { return isReady; },
         isReadyFromCache: function () { return isReadyFromCache; },

package/cjs/readiness/sdkReadinessManager.js

@@ -7,6 +7,7 @@ var readinessManager_1 = require("./readinessManager");
 var constants_1 = require("./constants");
 var constants_2 = require("../logger/constants");
 var NEW_LISTENER_EVENT = 'newListener';
+var REMOVE_LISTENER_EVENT = 'removeListener';
 var TIMEOUT_ERROR = new Error(constants_1.SDK_READY_TIMED_OUT);
 /**
  * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
@@ -18,11 +19,21 @@ var TIMEOUT_ERROR = new Error(constants_1.SDK_READY_TIMED_OUT);
 function sdkReadinessManagerFactory(EventEmitter, settings, readinessManager) {
     if (readinessManager === void 0) { readinessManager = (0, readinessManager_1.readinessManagerFactory)(EventEmitter, settings); }
     var log = settings.log;
+    /** Ready callback warning */
+    var internalReadyCbCount = 0;
+    var readyCbCount = 0;
+    readinessManager.gate.on(REMOVE_LISTENER_EVENT, function (event) {
+        if (event === constants_1.SDK_READY)
+            readyCbCount--;
+    });
     readinessManager.gate.on(NEW_LISTENER_EVENT, function (event) {
         if (event === constants_1.SDK_READY || event === constants_1.SDK_READY_TIMED_OUT) {
             if (readinessManager.isReady()) {
                 log.error(constants_2.ERROR_CLIENT_LISTENER, [event === constants_1.SDK_READY ? 'SDK_READY' : 'SDK_READY_TIMED_OUT']);
             }
+            else if (event === constants_1.SDK_READY) {
+                readyCbCount++;
+            }
         }
         else if (event === constants_1.SDK_READY_FROM_CACHE && readinessManager.isReadyFromCache()) {
             log.error(constants_2.ERROR_CLIENT_LISTENER, ['SDK_READY_FROM_CACHE']);
@@ -41,6 +52,8 @@ function sdkReadinessManagerFactory(EventEmitter, settings, readinessManager) {
         var promise = (0, wrapper_1.promiseWrapper)(new Promise(function (resolve, reject) {
             readinessManager.gate.once(constants_1.SDK_READY, function () {
                 log.info(constants_2.CLIENT_READY);
+                if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled())
+                    log.warn(constants_2.CLIENT_NO_LISTENER);
                 resolve();
             });
             readinessManager.gate.once(constants_1.SDK_READY_TIMED_OUT, function (message) {
@@ -65,6 +78,9 @@ function sdkReadinessManagerFactory(EventEmitter, settings, readinessManager) {
         shared: function () {
             return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
         },
+        incInternalReadyCbCount: function () {
+            internalReadyCbCount++;
+        },
         sdkStatus: (0, objectAssign_1.objectAssign)(
         // Expose Event Emitter functionality
         Object.create(readinessManager.gate), {
@@ -79,7 +95,7 @@ function sdkReadinessManagerFactory(EventEmitter, settings, readinessManager) {
             ready: function () {
                 if (readinessManager.hasTimedout()) {
                     if (!readinessManager.isReady()) {
-                        return (0, wrapper_1.promiseWrapper)(Promise.reject(new Error('SDK client has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
+                        return (0, wrapper_1.promiseWrapper)(Promise.reject(new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
                     }
                     else {
                         return Promise.resolve();

package/cjs/sdkClient/client.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clientFactory = exports.stringify = void 0;
+exports.clientFactory = void 0;
 var evaluator_1 = require("../evaluator");
 var thenable_1 = require("../utils/promise/thenable");
 var key_1 = require("../utils/key");
-var definitionExistence_1 = require("../utils/inputValidation/definitionExistence");
+var splitExistence_1 = require("../utils/inputValidation/splitExistence");
+var trafficTypeExistence_1 = require("../utils/inputValidation/trafficTypeExistence");
 var labels_1 = require("../utils/labels");
 var constants_1 = require("../utils/constants");
 var constants_2 = require("../logger/constants");
 var mode_1 = require("../utils/settingsValidation/mode");
-var trackMethod_1 = require("./trackMethod");
 var treatmentNotReady = { treatment: constants_1.CONTROL, label: labels_1.SDK_NOT_READY };
 function treatmentsNotReady(featureFlagNames) {
     var evaluations = {};
@@ -26,12 +26,11 @@ function stringify(options) {
         catch ( /* JSON.stringify should never throw with validated options, but handling just in case */_a) { /* JSON.stringify should never throw with validated options, but handling just in case */ }
     }
 }
-exports.stringify = stringify;
 /**
  * Creator of base client with getTreatments and track methods.
  */
 function clientFactory(params) {
-    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, telemetryTracker = params.telemetryTracker, fallbackCalculator = params.fallbackCalculator;
+    var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker, telemetryTracker = params.telemetryTracker, fallbackTreatmentsCalculator = params.fallbackTreatmentsCalculator;
     var log = settings.log, mode = settings.mode;
     var isAsync = (0, mode_1.isConsumerMode)(mode);
     function getTreatment(key, featureFlagName, attributes, options, withConfig, methodName) {
@@ -119,13 +118,13 @@ function clientFactory(params) {
         var changeNumber = evaluation.changeNumber, impressionsDisabled = evaluation.impressionsDisabled;
         var treatment = evaluation.treatment, label = evaluation.label, _a = evaluation.config, config = _a === void 0 ? null : _a;
         if (treatment === constants_1.CONTROL) {
-            var fallbackTreatment = fallbackCalculator(featureFlagName, label);
+            var fallbackTreatment = fallbackTreatmentsCalculator(featureFlagName, label);
             treatment = fallbackTreatment.treatment;
             label = fallbackTreatment.label;
             config = fallbackTreatment.config;
         }
-        if ((0, definitionExistence_1.validateDefinitionExistence)(log, readinessManager, featureFlagName, label, invokingMethodName)) {
-            log.info(constants_2.IMPRESSION_QUEUEING, ['Feature flag', featureFlagName, matchingKey, treatment, label]);
+        if ((0, splitExistence_1.validateSplitExistence)(log, readinessManager, featureFlagName, label, invokingMethodName)) {
+            log.info(constants_2.IMPRESSION_QUEUEING, [featureFlagName, matchingKey, treatment, label]);
             queue.push({
                 imp: {
                     feature: featureFlagName,
@@ -148,7 +147,33 @@ function clientFactory(params) {
         }
         return treatment;
     }
-    var track = (0, trackMethod_1.trackMethodFactory)(params);
+    function track(key, trafficTypeName, eventTypeId, value, properties, size) {
+        if (size === void 0) { size = 1024; }
+        var stopTelemetryTracker = telemetryTracker.trackEval(constants_1.TRACK);
+        var matchingKey = (0, key_1.getMatching)(key);
+        var timestamp = Date.now();
+        var eventData = {
+            eventTypeId: eventTypeId,
+            trafficTypeName: trafficTypeName,
+            value: value,
+            timestamp: timestamp,
+            key: matchingKey,
+            properties: properties
+        };
+        // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
+        (0, trafficTypeExistence_1.validateTrafficTypeExistence)(log, readinessManager, storage.splits, mode, trafficTypeName, constants_1.TRACK_FN_LABEL);
+        var result = eventTracker.track(eventData, size);
+        if ((0, thenable_1.thenable)(result)) {
+            return result.then(function (result) {
+                stopTelemetryTracker();
+                return result;
+            });
+        }
+        else {
+            stopTelemetryTracker();
+            return result;
+        }
+    }
     return {
         getTreatment: getTreatment,
         getTreatmentWithConfig: getTreatmentWithConfig,

package/cjs/sdkClient/clientInputValidation.js

@@ -10,7 +10,7 @@ var splitFilters_1 = require("../utils/settingsValidation/splitFilters");
  * 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.
  */
-function clientInputValidationDecorator(settings, client, readinessManager, fallbackCalculator) {
+function clientInputValidationDecorator(settings, client, readinessManager, fallbackTreatmentsCalculator) {
     var log = settings.log, mode = settings.mode;
     var isAsync = (0, mode_1.isConsumerMode)(mode);
     /**
@@ -21,12 +21,12 @@ function clientInputValidationDecorator(settings, client, readinessManager, fall
         var nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
             (0, splitFilters_1.validateFlagSets)(log, methodName, maybeNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
             (0, lang_1.startsWith)(methodName, constants_1.GET_TREATMENTS) ?
-                (0, inputValidation_1.validateDefinitions)(log, maybeNameOrNames, methodName) :
-                (0, inputValidation_1.validateDefinition)(log, maybeNameOrNames, methodName);
+                (0, inputValidation_1.validateSplits)(log, maybeNameOrNames, methodName) :
+                (0, inputValidation_1.validateSplit)(log, maybeNameOrNames, methodName);
         var attributes = (0, inputValidation_1.validateAttributes)(log, maybeAttributes, methodName);
         var isNotDestroyed = (0, inputValidation_1.validateIfNotDestroyed)(log, readinessManager, methodName);
         var options = (0, inputValidation_1.validateEvaluationOptions)(log, maybeOptions, methodName);
-        (0, inputValidation_1.validateIfReadyFromCache)(log, readinessManager, methodName);
+        (0, inputValidation_1.validateIfReadyFromCache)(log, readinessManager, methodName, nameOrNames);
         var valid = isNotDestroyed && key && nameOrNames && attributes !== false;
         return {
             valid: valid,
@@ -42,7 +42,7 @@ function clientInputValidationDecorator(settings, client, readinessManager, fall
             featureFlagName.forEach(function (split) { return res_1[split] = evaluateFallBackTreatment(split, withConfig); });
             return res_1;
         }
-        var _a = fallbackCalculator(featureFlagName), treatment = _a.treatment, config = _a.config;
+        var _a = fallbackTreatmentsCalculator(featureFlagName), treatment = _a.treatment, config = _a.config;
         return withConfig ?
             {
                 treatment: treatment,
@@ -100,6 +100,17 @@ function clientInputValidationDecorator(settings, client, readinessManager, fall
             client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options) :
             wrapResult({});
     }
+    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
+        var key = (0, inputValidation_1.validateKey)(log, maybeKey, constants_1.TRACK_FN_LABEL);
+        var tt = (0, inputValidation_1.validateTrafficType)(log, maybeTT, constants_1.TRACK_FN_LABEL);
+        var event = (0, inputValidation_1.validateEvent)(log, maybeEvent, constants_1.TRACK_FN_LABEL);
+        var eventValue = (0, inputValidation_1.validateEventValue)(log, maybeEventValue, constants_1.TRACK_FN_LABEL);
+        var _a = (0, inputValidation_1.validateEventProperties)(log, maybeProperties, constants_1.TRACK_FN_LABEL), properties = _a.properties, size = _a.size;
+        var isNotDestroyed = (0, inputValidation_1.validateIfNotDestroyed)(log, readinessManager, constants_1.TRACK_FN_LABEL);
+        return isNotDestroyed && key && tt && event && eventValue !== false && properties !== false ? // @ts-expect-error
+            client.track(key, tt, event, eventValue, properties, size) :
+            wrapResult(false);
+    }
     return {
         getTreatment: getTreatment,
         getTreatmentWithConfig: getTreatmentWithConfig,
@@ -109,7 +120,7 @@ function clientInputValidationDecorator(settings, client, readinessManager, fall
         getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
         getTreatmentsByFlagSet: getTreatmentsByFlagSet,
         getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
-        track: client.track,
+        track: track
     };
 }
 exports.clientInputValidationDecorator = clientInputValidationDecorator;

package/cjs/sdkClient/sdkClient.js

@@ -2,18 +2,75 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sdkClientFactory = void 0;
 var objectAssign_1 = require("../utils/lang/objectAssign");
+var apiKey_1 = require("../utils/inputValidation/apiKey");
 var client_1 = require("./client");
 var clientInputValidation_1 = require("./clientInputValidation");
-var sdkLifecycle_1 = require("./sdkLifecycle");
+var COOLDOWN_TIME_IN_MILLIS = 1000;
 /**
  * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
  */
 function sdkClientFactory(params, isSharedClient) {
-    var sdkReadinessManager = params.sdkReadinessManager, settings = params.settings;
+    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker, impressionsTracker = params.impressionsTracker;
+    var hasInit = false;
+    var lastActionTime = 0;
+    function __cooldown(func, time) {
+        var now = Date.now();
+        //get the actual time elapsed in ms
+        var timeElapsed = now - lastActionTime;
+        //check if the time elapsed is less than desired cooldown
+        if (timeElapsed < time) {
+            //if yes, return message with remaining time in seconds
+            settings.log.warn("Flush cooldown, remaining time ".concat((time - timeElapsed) / 1000, " seconds"));
+            return Promise.resolve();
+        }
+        else {
+            //Do the requested action and re-assign the lastActionTime
+            lastActionTime = now;
+            return func();
+        }
+    }
+    function __flush() {
+        return syncManager ? syncManager.flush() : Promise.resolve();
+    }
     return (0, objectAssign_1.objectAssign)(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
     // Client API (getTreatment* & track methods)
-    (0, clientInputValidation_1.clientInputValidationDecorator)(settings, (0, client_1.clientFactory)(params), sdkReadinessManager.readinessManager, params.fallbackCalculator), (0, sdkLifecycle_1.sdkLifecycleFactory)(params, isSharedClient));
+    (0, clientInputValidation_1.clientInputValidationDecorator)(settings, (0, client_1.clientFactory)(params), sdkReadinessManager.readinessManager, params.fallbackTreatmentsCalculator), {
+        init: function () {
+            if (hasInit)
+                return;
+            hasInit = true;
+            if (!isSharedClient) {
+                (0, apiKey_1.validateAndTrackApiKey)(settings.log, settings.core.authorizationKey);
+                sdkReadinessManager.readinessManager.init();
+                impressionsTracker.start();
+                syncManager && syncManager.start();
+                signalListener && signalListener.start();
+            }
+        },
+        flush: function () {
+            // @TODO define cooldown time
+            return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
+        },
+        destroy: function () {
+            hasInit = false;
+            // Mark the SDK as destroyed immediately
+            sdkReadinessManager.readinessManager.destroy();
+            // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
+            if (!isSharedClient) {
+                (0, apiKey_1.releaseApiKey)(settings.core.authorizationKey);
+                telemetryTracker.sessionLength();
+                signalListener && signalListener.stop();
+                impressionsTracker.stop();
+            }
+            // Stop background jobs
+            syncManager && syncManager.stop();
+            return __flush().then(function () {
+                // Cleanup storage
+                return storage.destroy();
+            });
+        }
+    });
 }
 exports.sdkClientFactory = sdkClientFactory;

package/cjs/sdkFactory/index.js

@@ -16,7 +16,7 @@ var fallbackTreatmentsCalculator_1 = require("../evaluator/fallbackTreatmentsCal
  * Modular SDK factory
  */
 function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, serviceApiFactory = params.serviceApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, lazyInit = params.lazyInit;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, lazyInit = params.lazyInit;
     var log = settings.log, initialRolloutPlan = settings.initialRolloutPlan, key = settings.core.key;
     // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
     // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
@@ -30,31 +30,35 @@ function sdkFactory(params) {
                 readiness.timeout();
                 return;
             }
-            readiness.definitions.emit(constants_2.SDK_DEFINITIONS_ARRIVED);
+            readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
             readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
         },
         onReadyFromCacheCb: function () {
-            readiness.definitions.emit(constants_2.SDK_DEFINITIONS_CACHE_LOADED);
+            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
         }
     });
-    var fallbackCalculator = (0, fallbackTreatmentsCalculator_1.FallbackTreatmentsCalculator)(settings.fallbackTreatments);
+    var fallbackTreatmentsCalculator = (0, fallbackTreatmentsCalculator_1.FallbackTreatmentsCalculator)(settings.fallbackTreatments);
     if (initialRolloutPlan) {
         (0, setRolloutPlan_1.setRolloutPlan)(log, initialRolloutPlan, storage, key && (0, key_1.getMatching)(key));
-        if (storage.definitions.getChangeNumber() > -1)
-            readiness.definitions.emit(constants_2.SDK_DEFINITIONS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
+        if (storage.splits.getChangeNumber() > -1)
+            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
     }
     var clients = {};
     var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
     var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(params, storage, integrationsManager);
     var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, integrationsManager, storage.telemetry);
-    // serviceApi is used by SyncManager and Browser signal listener
-    var serviceApi = serviceApiFactory && serviceApiFactory(settings, platform, telemetryTracker);
-    var ctx = { clients: clients, serviceApi: serviceApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, fallbackCalculator: fallbackCalculator };
-    ctx.syncManager = syncManagerFactory && syncManagerFactory(ctx);
+    // splitApi is used by SyncManager and Browser signal listener
+    var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
+    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, fallbackTreatmentsCalculator: fallbackTreatmentsCalculator };
+    var syncManager = syncManagerFactory && syncManagerFactory(ctx);
+    ctx.syncManager = syncManager;
+    // @TODO: move into platform, and call inside sdkClientFactory (if it's used only there)
+    var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
+    ctx.signalListener = signalListener;
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
-    var managerInstance = sdkManagerFactory(settings, storage.definitions, sdkReadinessManager);
+    var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
     function init() {
         Object.keys(clients).map(function (key) { return clients[key].init(); });
     }

package/cjs/sdkManager/index.js

@@ -53,18 +53,18 @@ function sdkManagerFactory(settings, splits, _a) {
          * Get the feature flag object corresponding to the given feature flag name if valid
          */
         split: function (featureFlagName) {
-            var splitName = (0, inputValidation_1.validateDefinition)(log, featureFlagName, constants_1.SPLIT_FN_LABEL);
+            var splitName = (0, inputValidation_1.validateSplit)(log, featureFlagName, constants_1.SPLIT_FN_LABEL);
             if (!(0, inputValidation_1.validateIfOperational)(log, readinessManager, constants_1.SPLIT_FN_LABEL) || !splitName) {
                 return isAsync ? Promise.resolve(null) : null;
             }
-            var split = splits.get(splitName);
+            var split = splits.getSplit(splitName);
             if ((0, thenable_1.thenable)(split)) {
                 return split.catch(function () { return null; }).then(function (result) {
-                    (0, inputValidation_1.validateDefinitionExistence)(log, readinessManager, splitName, result, constants_1.SPLIT_FN_LABEL);
+                    (0, inputValidation_1.validateSplitExistence)(log, readinessManager, splitName, result, constants_1.SPLIT_FN_LABEL);
                     return objectToView(result);
                 });
             }
-            (0, inputValidation_1.validateDefinitionExistence)(log, readinessManager, splitName, split, constants_1.SPLIT_FN_LABEL);
+            (0, inputValidation_1.validateSplitExistence)(log, readinessManager, splitName, split, constants_1.SPLIT_FN_LABEL);
             return objectToView(split);
         },
         /**
@@ -86,7 +86,7 @@ function sdkManagerFactory(settings, splits, _a) {
             if (!(0, inputValidation_1.validateIfOperational)(log, readinessManager, constants_1.NAMES_FN_LABEL)) {
                 return isAsync ? Promise.resolve([]) : [];
             }
-            var splitNames = splits.getNames();
+            var splitNames = splits.getSplitNames();
             return (0, thenable_1.thenable)(splitNames) ?
                 splitNames.catch(function () { return []; }) : // handle possible rejections when using pluggable storage
                 splitNames;

package/cjs/services/decorateHeaders.js

@@ -15,8 +15,7 @@ var FORBIDDEN_HEADERS = new Set([
     'content-encoding',
     'accept',
     'keep-alive',
-    'x-fastly-debug',
-    'x-harness-fme-sdk-version'
+    'x-fastly-debug'
 ]);
 function decorateHeaders(settings, headers) {
     var _a;

package/cjs/services/splitApi.js

@@ -9,9 +9,8 @@ var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
     return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
 }
-// @TODO remove when migrating to the new `urls` defaults.
 /**
- * Factory of ServiceApi objects, which group the collection of Split HTTP endpoints used by the SDK
+ * Factory of SplitApi objects, which group the collection of Split HTTP endpoints used by the SDK
  *
  * @param settings - validated settings object
  * @param platform - object containing environment-specific dependencies
@@ -126,18 +125,6 @@ function splitApiFactory(settings, platform, telemetryTracker) {
         postMetricsUsage: function (body, headers) {
             var url = "".concat(urls.telemetry, "/v1/metrics/usage");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(constants_1.TELEMETRY), true);
-        },
-        // Not used. Just here to satisfy the IServiceApi interface.
-        fetchConfigs: function (since, noCache, till, rbSince) {
-            var url = "".concat(urls.configs, "/v1/configs?since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
-        },
-        fetchConfigsSegmentChanges: function (since, segmentName, noCache, till) {
-            var url = "".concat(urls.configs, "/v1/segmentChanges/").concat(segmentName, "?since=").concat(since).concat(till ? '&till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
-        },
-        stop: function () {
-            // no-op
         }
     };
 }

package/cjs/services/splitHttpClient.js

@@ -24,17 +24,19 @@ function splitHttpClientFactory(settings, _a) {
     var commonHeaders = {
         'Accept': 'application/json',
         'Content-Type': 'application/json',
-        'Authorization': "Bearer ".concat(authorizationKey)
+        'Authorization': "Bearer ".concat(authorizationKey),
+        'SplitSDKVersion': version
     };
     if (ip)
         commonHeaders['SplitSDKMachineIP'] = ip;
     if (hostname)
         commonHeaders['SplitSDKMachineName'] = (0, decorateHeaders_1.removeNonISO88591)(hostname);
-    return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo, newVersionHeader) {
+    return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo) {
         if (reqOpts === void 0) { reqOpts = {}; }
         if (latencyTracker === void 0) { latencyTracker = function () { }; }
+        if (logErrorsAsInfo === void 0) { logErrorsAsInfo = false; }
         var request = (0, objectAssign_1.objectAssign)({
-            headers: (0, decorateHeaders_1.decorateHeaders)(settings, (0, objectAssign_1.objectAssign)(newVersionHeader ? { 'X-Harness-FME-SDK-Version': version } : { 'SplitSDKVersion': version }, commonHeaders, reqOpts.headers || {})),
+            headers: (0, decorateHeaders_1.decorateHeaders)(settings, (0, objectAssign_1.objectAssign)({}, commonHeaders, reqOpts.headers || {})),
             method: reqOpts.method || 'GET',
             body: reqOpts.body
         }, options);

package/cjs/storages/AbstractSplitsCacheAsync.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSplitsCacheAsync = void 0;
+var objectAssign_1 = require("../utils/lang/objectAssign");
+/**
+ * This class provides a skeletal implementation of the ISplitsCacheAsync interface
+ * to minimize the effort required to implement this interface.
+ */
+var AbstractSplitsCacheAsync = /** @class */ (function () {
+    function AbstractSplitsCacheAsync() {
+    }
+    AbstractSplitsCacheAsync.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        return Promise.all([
+            this.setChangeNumber(changeNumber),
+            Promise.all(toAdd.map(function (addedFF) { return _this.addSplit(addedFF); })),
+            Promise.all(toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }))
+        ]).then(function (_a) {
+            var added = _a[1], removed = _a[2];
+            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
+        });
+    };
+    // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
+    // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
+    AbstractSplitsCacheAsync.prototype.usesSegments = function () {
+        return Promise.resolve(true);
+    };
+    /**
+     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
+     * Used for SPLIT_KILL push notifications.
+     *
+     * @returns a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
+     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
+     * The promise will never be rejected.
+     */
+    AbstractSplitsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
+        var _this = this;
+        return this.getSplit(name).then(function (split) {
+            if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+                var newSplit = (0, objectAssign_1.objectAssign)({}, split);
+                newSplit.killed = true;
+                newSplit.defaultTreatment = defaultTreatment;
+                newSplit.changeNumber = changeNumber;
+                return _this.addSplit(newSplit);
+            }
+            return false;
+        }).catch(function () { return false; });
+    };
+    return AbstractSplitsCacheAsync;
+}());
+exports.AbstractSplitsCacheAsync = AbstractSplitsCacheAsync;