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

package/esm/listeners/node.js

@@ -10,8 +10,8 @@ var EVENT_NAME = 'for SIGTERM signal.';
  * the process is already exiting.
  */
 var NodeSignalListener = /** @class */ (function () {
-    function NodeSignalListener(_a) {
-        var syncManager = _a.syncManager, settings = _a.settings;
+    function NodeSignalListener(syncManager, // private handler: () => MaybeThenable<void>,
+    settings) {
         // @TODO review handler logic when implementing Node.js SDK
         this.handler = function () {
             if (syncManager) {
@@ -44,13 +44,13 @@ var NodeSignalListener = /** @class */ (function () {
             // eslint-disable-next-line no-undef
             process.kill(process.pid, SIGTERM);
         };
-        this.settings.log.debug("".concat(LOG_PREFIX_CLEANUP, "SDK graceful shutdown after SIGTERM."));
+        this.settings.log.debug("".concat(LOG_PREFIX_CLEANUP, "Split SDK graceful shutdown after SIGTERM."));
         var handlerResult = null;
         try {
             handlerResult = this.handler();
         }
         catch (err) {
-            this.settings.log.error("".concat(LOG_PREFIX_CLEANUP, "Error with SDK graceful shutdown: ").concat(err));
+            this.settings.log.error("".concat(LOG_PREFIX_CLEANUP, "Error with Split SDK graceful shutdown: ").concat(err));
         }
         if (thenable(handlerResult)) {
             // Always exit, even with errors. The promise is returned for UT purposes.

package/esm/logger/constants.js

@@ -19,8 +19,9 @@ export var RETRIEVE_CLIENT_DEFAULT = 27;
 export var RETRIEVE_CLIENT_EXISTING = 28;
 export var RETRIEVE_MANAGER = 29;
 export var SYNC_OFFLINE_DATA = 30;
-export var SYNC_FETCH = 31;
-export var SYNC_UPDATE = 32;
+export var SYNC_SPLITS_FETCH = 31;
+export var SYNC_SPLITS_UPDATE = 32;
+export var SYNC_RBS_UPDATE = 33;
 export var STREAMING_NEW_MESSAGE = 35;
 export var SYNC_TASK_START = 36;
 export var SYNC_TASK_EXECUTE = 37;
@@ -36,6 +37,7 @@ export var NEW_FACTORY = 105;
 export var POLLING_SMART_PAUSING = 106;
 export var POLLING_START = 107;
 export var POLLING_STOP = 108;
+export var SYNC_SPLITS_FETCH_RETRY = 109;
 export var STREAMING_REFRESH_TOKEN = 110;
 export var STREAMING_RECONNECT = 111;
 export var STREAMING_CONNECTING = 112;
@@ -54,9 +56,10 @@ export var USER_CONSENT_INITIAL = 124;
 export var SUBMITTERS_PUSH_PAGE_HIDDEN = 125;
 export var ENGINE_VALUE_INVALID = 200;
 export var ENGINE_VALUE_NO_ATTRIBUTES = 201;
+export var CLIENT_NO_LISTENER = 202;
 export var CLIENT_NOT_READY_FROM_CACHE = 203;
-export var SYNC_FETCH_RETRY = 204;
-export var SYNC_FETCH_FAILS = 205;
+export var SYNC_MYSEGMENTS_FETCH_RETRY = 204;
+export var SYNC_SPLITS_FETCH_FAILS = 205;
 export var STREAMING_PARSING_ERROR_FAILS = 206;
 export var STREAMING_PARSING_MESSAGE_FAILS = 207;
 export var STREAMING_FALLBACK = 208;
@@ -66,7 +69,7 @@ export var WARN_SETTING_NULL = 211;
 export var WARN_TRIMMING_PROPERTIES = 212;
 export var WARN_CONVERTING = 213;
 export var WARN_TRIMMING = 214;
-export var WARN_NOT_EXISTENT_DEFINITION = 215;
+export var WARN_NOT_EXISTENT_SPLIT = 215;
 export var WARN_LOWERCASE_TRAFFIC_TYPE = 216;
 export var WARN_NOT_EXISTENT_TT = 217;
 export var WARN_INTEGRATION_INVALID = 218;
@@ -117,13 +120,15 @@ export var LOG_PREFIX_ENGINE = 'engine';
 export var LOG_PREFIX_ENGINE_COMBINER = LOG_PREFIX_ENGINE + ':combiner: ';
 export var LOG_PREFIX_ENGINE_MATCHER = LOG_PREFIX_ENGINE + ':matcher: ';
 export var LOG_PREFIX_ENGINE_VALUE = LOG_PREFIX_ENGINE + ':value: ';
-export var LOG_PREFIX_SYNC = 'sync: ';
-export var LOG_PREFIX_SYNC_AUTH = 'sync:auth: ';
-export var LOG_PREFIX_SYNC_MANAGER = 'sync:sync-manager: ';
-export var LOG_PREFIX_SYNC_OFFLINE = 'sync:offline: ';
-export var LOG_PREFIX_SYNC_STREAMING = 'sync:streaming: ';
-export var LOG_PREFIX_SYNC_POLLING = 'sync:polling-manager: ';
-export var LOG_PREFIX_SYNC_SUBMITTERS = 'sync:submitter: ';
+export var LOG_PREFIX_SYNC = 'sync';
+export var LOG_PREFIX_SYNC_MANAGER = LOG_PREFIX_SYNC + ':sync-manager: ';
+export var LOG_PREFIX_SYNC_OFFLINE = LOG_PREFIX_SYNC + ':offline: ';
+export var LOG_PREFIX_SYNC_STREAMING = LOG_PREFIX_SYNC + ':streaming: ';
+export var LOG_PREFIX_SYNC_SPLITS = LOG_PREFIX_SYNC + ':featureflag-changes: ';
+export var LOG_PREFIX_SYNC_SEGMENTS = LOG_PREFIX_SYNC + ':segment-changes: ';
+export var LOG_PREFIX_SYNC_MYSEGMENTS = LOG_PREFIX_SYNC + ':my-segments: ';
+export var LOG_PREFIX_SYNC_POLLING = LOG_PREFIX_SYNC + ':polling-manager: ';
+export var LOG_PREFIX_SYNC_SUBMITTERS = LOG_PREFIX_SYNC + ':submitter: ';
 export var LOG_PREFIX_IMPRESSIONS_TRACKER = 'impressions-tracker: ';
 export var LOG_PREFIX_EVENTS_TRACKER = 'events-tracker: ';
 export var LOG_PREFIX_UNIQUE_KEYS_TRACKER = 'unique-keys-tracker: ';

package/esm/logger/messages/debug.js

@@ -20,12 +20,13 @@ export var codesDebug = codesInfo.concat([
     [c.RETRIEVE_MANAGER, 'Retrieving manager instance.'],
     // synchronizer
     [c.SYNC_OFFLINE_DATA, c.LOG_PREFIX_SYNC_OFFLINE + 'Feature flags data: \n%s'],
-    [c.SYNC_FETCH, c.LOG_PREFIX_SYNC + 'Spin up %s updates using since = %s and rbSince = %s.'],
-    [c.SYNC_UPDATE, c.LOG_PREFIX_SYNC + 'Updated %s: %s. Removed: %s.'],
+    [c.SYNC_SPLITS_FETCH, c.LOG_PREFIX_SYNC_SPLITS + 'Spin up feature flags update using since = %s and rbSince = %s.'],
+    [c.SYNC_SPLITS_UPDATE, c.LOG_PREFIX_SYNC_SPLITS + 'New feature flags: %s. Removed feature flags: %s.'],
+    [c.SYNC_RBS_UPDATE, c.LOG_PREFIX_SYNC_SPLITS + 'New rule-based segments: %s. Removed rule-based segments: %s.'],
     [c.STREAMING_NEW_MESSAGE, c.LOG_PREFIX_SYNC_STREAMING + 'New SSE message received, with data: %s.'],
-    [c.SYNC_TASK_START, c.LOG_PREFIX_SYNC + 'Starting %s. Running each %s millis'],
-    [c.SYNC_TASK_EXECUTE, c.LOG_PREFIX_SYNC + 'Running %s'],
-    [c.SYNC_TASK_STOP, c.LOG_PREFIX_SYNC + 'Stopping %s'],
+    [c.SYNC_TASK_START, c.LOG_PREFIX_SYNC + ': Starting %s. Running each %s millis'],
+    [c.SYNC_TASK_EXECUTE, c.LOG_PREFIX_SYNC + ': Running %s'],
+    [c.SYNC_TASK_STOP, c.LOG_PREFIX_SYNC + ': Stopping %s'],
     // initialization / settings validation
     [c.SETTINGS_SPLITS_FILTER, c.LOG_PREFIX_SETTINGS + ': feature flags filtering criteria is "%s".']
 ]);

package/esm/logger/messages/error.js

@@ -1,7 +1,7 @@
 import * as c from '../constants';
 export var codesError = [
     // evaluator
-    [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid definition, no valid rules or unsupported targeting rule type found'],
+    [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid feature flag, no valid rules or unsupported targeting rule type found'],
     [c.ENGINE_MATCHER_ERROR, c.LOG_PREFIX_ENGINE_MATCHER + '[%s] %s'],
     // SDK
     [c.ERROR_LOGLEVEL_INVALID, 'logger: Invalid Log Level - No changes to the logs will be applied.'],
@@ -12,7 +12,7 @@ export var codesError = [
     // synchronizer
     [c.ERROR_SYNC_OFFLINE_LOADING, c.LOG_PREFIX_SYNC_OFFLINE + 'There was an issue loading the mock feature flags data. No changes will be applied to the current cache. %s'],
     [c.ERROR_STREAMING_SSE, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to connect or error on streaming connection, with error message: %s'],
-    [c.ERROR_STREAMING_AUTH, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to authenticate for streaming. Error: %s'],
+    [c.ERROR_STREAMING_AUTH, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to authenticate for streaming. Error: %s.'],
     [c.ERROR_HTTP, 'HTTP request failed with %s. URL: %s. Message: %s'],
     // client status
     [c.ERROR_CLIENT_LISTENER, 'A listener was added for %s on the SDK, which has already fired and won\'t be emitted again. The callback won\'t be executed.'],
@@ -33,6 +33,6 @@ export var codesError = [
     [c.ERROR_INVALID_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "%s" config param. It should be one of the following values: %s. Defaulting to "%s".'],
     [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS + ': the provided storage is invalid.%s Falling back into default MEMORY storage'],
     [c.ERROR_MIN_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': the provided "%s" config param is lower than allowed. Setting to the minimum value %s seconds'],
-    [c.ERROR_TOO_MANY_SETS, c.LOG_PREFIX_SETTINGS + ': the number of sets provided is too high, which causes a URI length error.'],
+    [c.ERROR_TOO_MANY_SETS, c.LOG_PREFIX_SETTINGS + ': the amount of flag sets provided are big causing uri length error.'],
     [c.ERROR_SETS_FILTER_EXCLUSIVE, c.LOG_PREFIX_SETTINGS + ': the Set filter is exclusive and cannot be used simultaneously with names or prefix filters. Ignoring names and prefixes.'],
 ];

package/esm/logger/messages/info.js

@@ -1,14 +1,14 @@
 import * as c from '../constants';
 import { codesWarn } from './warn';
-var READY_MSG = 'SDK client is ready';
+var READY_MSG = 'Split SDK client is ready';
 export var codesInfo = codesWarn.concat([
     // client status
     [c.CLIENT_READY_FROM_CACHE, READY_MSG + ' from cache'],
     [c.CLIENT_READY, READY_MSG],
     // SDK
-    [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Queueing impression. %s: %s. Key: %s. Evaluation: %s. Label: %s'],
+    [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Queueing impression. Feature flag: %s. Key: %s. Evaluation: %s. Label: %s'],
     [c.NEW_SHARED_CLIENT, 'New shared client instance created.'],
-    [c.NEW_FACTORY, 'New SDK instance created. %s'],
+    [c.NEW_FACTORY, 'New Split SDK instance created. %s'],
     [c.EVENTS_TRACKER_SUCCESS, c.LOG_PREFIX_EVENTS_TRACKER + 'Successfully queued %s'],
     [c.IMPRESSIONS_TRACKER_SUCCESS, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Successfully stored %s impression(s).'],
     [c.USER_CONSENT_UPDATED, 'UserConsent: consent status changed from %s to %s.'],
@@ -18,6 +18,7 @@ export var codesInfo = codesWarn.concat([
     [c.POLLING_SMART_PAUSING, c.LOG_PREFIX_SYNC_POLLING + 'Turning segments data polling %s.'],
     [c.POLLING_START, c.LOG_PREFIX_SYNC_POLLING + 'Starting polling'],
     [c.POLLING_STOP, c.LOG_PREFIX_SYNC_POLLING + 'Stopping polling'],
+    [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying fetch of feature flags (attempt #%s). Reason: %s'],
     [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and resetting timer.'],
     [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
     [c.SUBMITTERS_PUSH_PAGE_HIDDEN, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing %s because page became hidden.'],

package/esm/logger/messages/warn.js

@@ -5,21 +5,22 @@ export var codesWarn = codesError.concat([
     [c.ENGINE_VALUE_INVALID, c.LOG_PREFIX_ENGINE_VALUE + 'Value %s doesn\'t match with expected type.'],
     [c.ENGINE_VALUE_NO_ATTRIBUTES, c.LOG_PREFIX_ENGINE_VALUE + 'Defined attribute `%s`. No attributes received.'],
     // synchronizer
-    [c.SYNC_FETCH_RETRY, c.LOG_PREFIX_SYNC + 'Retrying fetch of %s (attempt #%s). Reason: %s'],
-    [c.SYNC_FETCH_FAILS, c.LOG_PREFIX_SYNC + 'Error while doing fetch of %s. %s'],
+    [c.SYNC_MYSEGMENTS_FETCH_RETRY, c.LOG_PREFIX_SYNC_MYSEGMENTS + 'Retrying fetch of memberships (attempt #%s). Reason: %s'],
+    [c.SYNC_SPLITS_FETCH_FAILS, c.LOG_PREFIX_SYNC_SPLITS + 'Error while doing fetch of feature flags. %s'],
     [c.STREAMING_PARSING_ERROR_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE error notification: %s'],
     [c.STREAMING_PARSING_MESSAGE_FAILS, c.LOG_PREFIX_SYNC_STREAMING + 'Error parsing SSE message notification: %s'],
     [c.STREAMING_FALLBACK, c.LOG_PREFIX_SYNC_STREAMING + 'Falling back to polling mode. Reason: %s'],
-    [c.SUBMITTERS_PUSH_FAILS, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Dropping %s after retry. Reason: %s'],
-    [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s, keeping data to retry on next iteration. Reason: %s'],
+    [c.SUBMITTERS_PUSH_FAILS, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Dropping %s after retry. Reason: %s.'],
+    [c.SUBMITTERS_PUSH_RETRY, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Failed to push %s, keeping data to retry on next iteration. Reason: %s.'],
     // client status
-    [c.CLIENT_NOT_READY_FROM_CACHE, '%s: the SDK is not ready to evaluate. Results may be incorrect. Make sure to wait for SDK readiness before using this method.'],
+    [c.CLIENT_NOT_READY_FROM_CACHE, '%s: the SDK is not ready to evaluate. Results may be incorrect%s. Make sure to wait for SDK readiness before using this method.'],
+    [c.CLIENT_NO_LISTENER, 'No listeners for SDK_READY event detected. Incorrect control treatments could have been logged if you called getTreatment/s while the SDK was not yet synchronized with the backend.'],
     // input validation
     [c.WARN_SETTING_NULL, '%s: Property "%s" is of invalid type. Setting value to null.'],
     [c.WARN_TRIMMING_PROPERTIES, '%s: more than 300 properties were provided. Some of them will be trimmed when processed.'],
     [c.WARN_CONVERTING, '%s: %s "%s" is not of type string, converting.'],
     [c.WARN_TRIMMING, '%s: %s "%s" has extra whitespace, trimming.'],
-    [c.WARN_NOT_EXISTENT_DEFINITION, '%s: "%s" does not exist in this environment. Please double check that it exists in Harness FME UI.'],
+    [c.WARN_NOT_EXISTENT_SPLIT, '%s: feature flag "%s" does not exist in this environment. Please double check what feature flags exist in Harness FME UI.'],
     [c.WARN_LOWERCASE_TRAFFIC_TYPE, '%s: traffic_type_name should be all lowercase - converting string to lowercase.'],
     [c.WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding feature flag in this environment, make sure you\'re tracking your events to a valid traffic type defined in Harness FME UI.'],
     [c.WARN_FLAGSET_NOT_CONFIGURED, '%s: you passed %s which is not part of the configured FlagSetsFilter, ignoring Flag Set.'],

package/esm/presets/serverSide.js

@@ -1,4 +1,4 @@
-import { serviceApiFactory } from '../services/serviceApi';
+import { splitApiFactory } from '../services/splitApi';
 import { syncManagerOnlineFactory } from '../sync/syncManagerOnline';
 import { pushManagerFactory } from '../sync/streaming/pushManager';
 import { pollingManagerSSFactory } from '../sync/polling/pollingManagerSS';
@@ -9,7 +9,7 @@ import { impressionObserverSSFactory } from '../trackers/impressionObserver/impr
 var syncManagerOnlineSSFactory = syncManagerOnlineFactory(pollingManagerSSFactory, pushManagerFactory);
 export var serverSideModules = {
     storageFactory: InMemoryStorageFactory,
-    serviceApiFactory: serviceApiFactory,
+    splitApiFactory: splitApiFactory,
     syncManagerFactory: syncManagerOnlineSSFactory,
     sdkManagerFactory: sdkManagerFactory,
     sdkClientMethodFactory: sdkClientMethodFactory,

package/esm/readiness/constants.js

@@ -1,6 +1,6 @@
-// Definitions events:
-export var SDK_DEFINITIONS_ARRIVED = 'state::splits-arrived';
-export var SDK_DEFINITIONS_CACHE_LOADED = 'state::splits-cache-loaded';
+// Splits events:
+export var SDK_SPLITS_ARRIVED = 'state::splits-arrived';
+export var SDK_SPLITS_CACHE_LOADED = 'state::splits-cache-loaded';
 // Segments events:
 export var SDK_SEGMENTS_ARRIVED = 'state::segments-arrived';
 // Readiness events:
@@ -11,4 +11,3 @@ export var SDK_UPDATE = 'state::update';
 // SdkUpdateMetadata types:
 export var FLAGS_UPDATE = 'FLAGS_UPDATE';
 export var SEGMENTS_UPDATE = 'SEGMENTS_UPDATE';
-export var CONFIGS_UPDATE = 'CONFIGS_UPDATE';

package/esm/readiness/readinessManager.js

@@ -1,19 +1,19 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { SDK_DEFINITIONS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
-function definitionsEventEmitterFactory(EventEmitter) {
-    var definitionsEventEmitter = objectAssign(new EventEmitter(), {
-        definitionsArrived: false,
-        definitionsCacheLoaded: false,
+import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
+function splitsEventEmitterFactory(EventEmitter) {
+    var splitsEventEmitter = 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(SDK_DEFINITIONS_ARRIVED, function (metadata, isSplitKill) { if (!isSplitKill)
-        definitionsEventEmitter.definitionsArrived = true; });
-    definitionsEventEmitter.once(SDK_DEFINITIONS_CACHE_LOADED, function () { definitionsEventEmitter.definitionsCacheLoaded = true; });
-    return definitionsEventEmitter;
+    splitsEventEmitter.on(SDK_SPLITS_ARRIVED, function (metadata, isSplitKill) { if (!isSplitKill)
+        splitsEventEmitter.splitsArrived = true; });
+    splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, function () { splitsEventEmitter.splitsCacheLoaded = true; });
+    return splitsEventEmitter;
 }
 function segmentsEventEmitterFactory(EventEmitter) {
     var segmentsEventEmitter = objectAssign(new EventEmitter(), {
@@ -25,8 +25,8 @@ function segmentsEventEmitterFactory(EventEmitter) {
 /**
  * Factory of readiness manager, which handles the ready / update event propagation.
  */
-export function readinessManagerFactory(EventEmitter, settings, definitions, isShared) {
-    if (definitions === void 0) { definitions = definitionsEventEmitterFactory(EventEmitter); }
+export 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();
@@ -41,10 +41,10 @@ export function readinessManagerFactory(EventEmitter, settings, definitions, isS
     };
     // 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(SDK_DEFINITIONS_CACHE_LOADED, checkIsReadyFromCache);
+        splits.once(SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
     // emit SDK_READY_TIMED_OUT
     var hasTimedout = false;
     function timeout() {
@@ -52,11 +52,11 @@ export function readinessManagerFactory(EventEmitter, settings, definitions, isS
             return;
         hasTimedout = true;
         syncLastUpdate();
-        gate.emit(SDK_READY_TIMED_OUT, 'SDK client emitted SDK_READY_TIMED_OUT event.');
+        gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
     }
     // emit SDK_READY and SDK_UPDATE
     var isReady = false;
-    definitions.on(SDK_DEFINITIONS_ARRIVED, checkIsReadyOrUpdate);
+    splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
     segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
     var isDestroyed = false;
     var readyTimeoutId;
@@ -65,8 +65,8 @@ export function readinessManagerFactory(EventEmitter, settings, definitions, isS
         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;
@@ -97,7 +97,7 @@ export function readinessManagerFactory(EventEmitter, settings, definitions, isS
             }
         }
         else {
-            if (definitions.definitionsArrived && segments.segmentsArrived) {
+            if (splits.splitsArrived && segments.segmentsArrived) {
                 clearTimeout(readyTimeoutId);
                 isReady = true;
                 try {
@@ -120,11 +120,11 @@ export function readinessManagerFactory(EventEmitter, settings, definitions, isS
         }
     }
     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
@@ -133,17 +133,17 @@ export function readinessManagerFactory(EventEmitter, settings, definitions, isS
         // 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/esm/readiness/sdkReadinessManager.js

@@ -2,8 +2,9 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { promiseWrapper } from '../utils/promise/wrapper';
 import { readinessManagerFactory } from './readinessManager';
 import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
-import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY } from '../logger/constants';
+import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
 var NEW_LISTENER_EVENT = 'newListener';
+var REMOVE_LISTENER_EVENT = 'removeListener';
 var TIMEOUT_ERROR = new Error(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).
@@ -15,11 +16,21 @@ var TIMEOUT_ERROR = new Error(SDK_READY_TIMED_OUT);
 export function sdkReadinessManagerFactory(EventEmitter, settings, readinessManager) {
     if (readinessManager === void 0) { readinessManager = 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 === SDK_READY)
+            readyCbCount--;
+    });
     readinessManager.gate.on(NEW_LISTENER_EVENT, function (event) {
         if (event === SDK_READY || event === SDK_READY_TIMED_OUT) {
             if (readinessManager.isReady()) {
                 log.error(ERROR_CLIENT_LISTENER, [event === SDK_READY ? 'SDK_READY' : 'SDK_READY_TIMED_OUT']);
             }
+            else if (event === SDK_READY) {
+                readyCbCount++;
+            }
         }
         else if (event === SDK_READY_FROM_CACHE && readinessManager.isReadyFromCache()) {
             log.error(ERROR_CLIENT_LISTENER, ['SDK_READY_FROM_CACHE']);
@@ -38,6 +49,8 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
         var promise = promiseWrapper(new Promise(function (resolve, reject) {
             readinessManager.gate.once(SDK_READY, function () {
                 log.info(CLIENT_READY);
+                if (readyCbCount === internalReadyCbCount && !promise.hasOnFulfilled())
+                    log.warn(CLIENT_NO_LISTENER);
                 resolve();
             });
             readinessManager.gate.once(SDK_READY_TIMED_OUT, function (message) {
@@ -62,6 +75,9 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
         shared: function () {
             return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
         },
+        incInternalReadyCbCount: function () {
+            internalReadyCbCount++;
+        },
         sdkStatus: objectAssign(
         // Expose Event Emitter functionality
         Object.create(readinessManager.gate), {
@@ -76,7 +92,7 @@ export function sdkReadinessManagerFactory(EventEmitter, settings, readinessMana
             ready: function () {
                 if (readinessManager.hasTimedout()) {
                     if (!readinessManager.isReady()) {
-                        return promiseWrapper(Promise.reject(new Error('SDK client has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
+                        return promiseWrapper(Promise.reject(new Error('Split SDK has emitted SDK_READY_TIMED_OUT event.')), defaultOnRejected);
                     }
                     else {
                         return Promise.resolve();

package/esm/sdkClient/client.js

@@ -1,12 +1,12 @@
 import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } from '../evaluator';
 import { thenable } from '../utils/promise/thenable';
 import { getMatching, getBucketing } from '../utils/key';
-import { validateDefinitionExistence } from '../utils/inputValidation/definitionExistence';
+import { validateSplitExistence } from '../utils/inputValidation/splitExistence';
+import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
 import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS } from '../utils/constants';
+import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, TRACK_FN_LABEL } from '../utils/constants';
 import { IMPRESSION_QUEUEING } from '../logger/constants';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
-import { trackMethodFactory } from './trackMethod';
 var treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 function treatmentsNotReady(featureFlagNames) {
     var evaluations = {};
@@ -15,7 +15,7 @@ function treatmentsNotReady(featureFlagNames) {
     });
     return evaluations;
 }
-export function stringify(options) {
+function stringify(options) {
     if (options && options.properties) {
         try {
             return JSON.stringify(options.properties);
@@ -27,7 +27,7 @@ export function stringify(options) {
  * Creator of base client with getTreatments and track methods.
  */
 export 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 = isConsumerMode(mode);
     function getTreatment(key, featureFlagName, attributes, options, withConfig, methodName) {
@@ -115,13 +115,13 @@ export 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 === CONTROL) {
-            var fallbackTreatment = fallbackCalculator(featureFlagName, label);
+            var fallbackTreatment = fallbackTreatmentsCalculator(featureFlagName, label);
             treatment = fallbackTreatment.treatment;
             label = fallbackTreatment.label;
             config = fallbackTreatment.config;
         }
-        if (validateDefinitionExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
-            log.info(IMPRESSION_QUEUEING, ['Feature flag', featureFlagName, matchingKey, treatment, label]);
+        if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
+            log.info(IMPRESSION_QUEUEING, [featureFlagName, matchingKey, treatment, label]);
             queue.push({
                 imp: {
                     feature: featureFlagName,
@@ -144,7 +144,33 @@ export function clientFactory(params) {
         }
         return treatment;
     }
-    var track = trackMethodFactory(params);
+    function track(key, trafficTypeName, eventTypeId, value, properties, size) {
+        if (size === void 0) { size = 1024; }
+        var stopTelemetryTracker = telemetryTracker.trackEval(TRACK);
+        var matchingKey = 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.
+        validateTrafficTypeExistence(log, readinessManager, storage.splits, mode, trafficTypeName, TRACK_FN_LABEL);
+        var result = eventTracker.track(eventData, size);
+        if (thenable(result)) {
+            return result.then(function (result) {
+                stopTelemetryTracker();
+                return result;
+            });
+        }
+        else {
+            stopTelemetryTracker();
+            return result;
+        }
+    }
     return {
         getTreatment: getTreatment,
         getTreatmentWithConfig: getTreatmentWithConfig,

package/esm/sdkClient/clientInputValidation.js

@@ -1,13 +1,13 @@
-import { validateAttributes, validateKey, validateDefinition, validateDefinitions, validateIfNotDestroyed, validateIfReadyFromCache, validateEvaluationOptions } from '../utils/inputValidation';
+import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfReadyFromCache, validateEvaluationOptions } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
-import { GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG } from '../utils/constants';
+import { GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG, TRACK_FN_LABEL } from '../utils/constants';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { validateFlagSets } from '../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.
  */
-export function clientInputValidationDecorator(settings, client, readinessManager, fallbackCalculator) {
+export function clientInputValidationDecorator(settings, client, readinessManager, fallbackTreatmentsCalculator) {
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     /**
@@ -18,12 +18,12 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         var nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
             validateFlagSets(log, methodName, maybeNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
             startsWith(methodName, GET_TREATMENTS) ?
-                validateDefinitions(log, maybeNameOrNames, methodName) :
-                validateDefinition(log, maybeNameOrNames, methodName);
+                validateSplits(log, maybeNameOrNames, methodName) :
+                validateSplit(log, maybeNameOrNames, methodName);
         var attributes = validateAttributes(log, maybeAttributes, methodName);
         var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
         var options = validateEvaluationOptions(log, maybeOptions, methodName);
-        validateIfReadyFromCache(log, readinessManager, methodName);
+        validateIfReadyFromCache(log, readinessManager, methodName, nameOrNames);
         var valid = isNotDestroyed && key && nameOrNames && attributes !== false;
         return {
             valid: valid,
@@ -39,7 +39,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             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,
@@ -97,6 +97,17 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options) :
             wrapResult({});
     }
+    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
+        var key = validateKey(log, maybeKey, TRACK_FN_LABEL);
+        var tt = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
+        var event = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
+        var eventValue = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
+        var _a = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL), properties = _a.properties, size = _a.size;
+        var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, 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,
@@ -106,6 +117,6 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
         getTreatmentsByFlagSet: getTreatmentsByFlagSet,
         getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
-        track: client.track,
+        track: track
     };
 }