@splitsoftware/splitio-commons 1.8.2-rc.0 → 1.8.2-rc.2

package/src/logger/messages/error.ts

@@ -2,7 +2,7 @@ import * as c from '../constants';
 
 export const codesError: [number, string][] = [
   // evaluator
-  [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid Split, no valid rules found'],
+  [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid feature flag, no valid rules found'],
   // SDK
   [c.ERROR_LOGLEVEL_INVALID, 'logger: Invalid Log Level - No changes to the logs will be applied.'],
   [c.ERROR_CLIENT_CANNOT_GET_READY, 'The SDK will not get ready. Reason: %s'],
@@ -10,7 +10,7 @@ export const codesError: [number, string][] = [
   [c.ERROR_IMPRESSIONS_LISTENER, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Impression listener logImpression method threw: %s.'],
   [c.ERROR_EVENTS_TRACKER, c.LOG_PREFIX_EVENTS_TRACKER + 'Failed to queue %s'],
   // synchronizer
-  [c.ERROR_SYNC_OFFLINE_LOADING, c.LOG_PREFIX_SYNC_OFFLINE + 'There was an issue loading the mock Splits data, no changes will be applied to the current cache. %s'],
+  [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_HTTP, 'Response status is not OK. Status: %s. URL: %s. Message: %s'],

package/src/logger/messages/info.ts

@@ -8,7 +8,7 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.CLIENT_READY_FROM_CACHE, READY_MSG + ' from cache'],
   [c.CLIENT_READY, READY_MSG],
   // SDK
-  [c.IMPRESSION, c.LOG_PREFIX_IMPRESSIONS_TRACKER +'Split: %s. Key: %s. Evaluation: %s. Label: %s'],
+  [c.IMPRESSION, c.LOG_PREFIX_IMPRESSIONS_TRACKER +'Feature flag: %s. Key: %s. Evaluation: %s. Label: %s'],
   [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER +'Queueing corresponding impression.'],
   [c.NEW_SHARED_CLIENT, 'New shared client instance created.'],
   [c.NEW_FACTORY, 'New Split SDK instance created.'],
@@ -22,13 +22,13 @@ export const codesInfo: [number, string][] = 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 download of splits #%s. Reason: %s'],
+  [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of feature flags #%s. Reason: %s'],
   [c.SUBMITTERS_PUSH_FULL_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full %s queue and reseting timer.'],
   [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s.'],
   [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
   [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect streaming in %s seconds.'],
   [c.STREAMING_CONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Connecting streaming.'],
-  [c.STREAMING_DISABLED, c.LOG_PREFIX_SYNC_STREAMING + 'Streaming is disabled for given Api key. Switching to polling mode.'],
+  [c.STREAMING_DISABLED, c.LOG_PREFIX_SYNC_STREAMING + 'Streaming is disabled for given SDK key. Switching to polling mode.'],
   [c.STREAMING_DISCONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Disconnecting streaming.'],
   [c.SYNC_START_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming not available. Starting polling.'],
   [c.SYNC_CONTINUE_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming couldn\'t connect. Continue polling.'],

package/src/logger/messages/warn.ts

@@ -7,7 +7,7 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.ENGINE_VALUE_NO_ATTRIBUTES, c.LOG_PREFIX_ENGINE_VALUE + 'Defined attribute [%s], no attributes received.'],
   // synchronizer
   [c.SYNC_MYSEGMENTS_FETCH_RETRY, c.LOG_PREFIX_SYNC_MYSEGMENTS + 'Retrying download of segments #%s. Reason: %s'],
-  [c.SYNC_SPLITS_FETCH_FAILS, c.LOG_PREFIX_SYNC_SPLITS + 'Error while doing fetch of Splits. %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'],
@@ -21,15 +21,15 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.WARN_TRIMMING_PROPERTIES, '%s: Event has more than 300 properties. 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_SPLIT, '%s: split "%s" does not exist in this environment, please double check what splits exist in the Split web console.'],
+  [c.WARN_NOT_EXISTENT_SPLIT, '%s: feature flag "%s" does not exist in this environment. Please double check what feature flags exist in the Split user interface.'],
   [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 split in this environment, make sure you\'re tracking your events to a valid traffic type defined in the Split web console.'],
+  [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 the Split user interface.'],
   // initialization / settings validation
   [c.WARN_INTEGRATION_INVALID, c.LOG_PREFIX_SETTINGS+': %s integration item(s) at settings is invalid. %s'],
-  [c.WARN_SPLITS_FILTER_IGNORED, c.LOG_PREFIX_SETTINGS+': split filters have been configured but will have no effect if mode is not "%s", since synchronization is being deferred to an external tool.'],
-  [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS+': split filter at position %s is invalid. It must be an object with a valid filter type ("byName" or "byPrefix") and a list of "values".'],
-  [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS+': splitFilters configuration must be a non-empty array of filter objects.'],
-  [c.WARN_API_KEY, c.LOG_PREFIX_SETTINGS+': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
+  [c.WARN_SPLITS_FILTER_IGNORED, c.LOG_PREFIX_SETTINGS+': feature flag filters have been configured but will have no effect if mode is not "%s", since synchronization is being deferred to an external tool.'],
+  [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS+': feature flag filter at position %s is invalid. It must be an object with a valid filter type ("byName" or "byPrefix") and a list of "values".'],
+  [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS+': feature flag filter configuration must be a non-empty array of filter objects.'],
+  [c.WARN_SDK_KEY, c.LOG_PREFIX_SETTINGS+': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
 
   [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],
 ]);

package/src/sdkClient/client.ts

@@ -13,10 +13,10 @@ import { isStorageSync } from '../trackers/impressionObserver/utils';
 
 const treatmentNotReady = { treatment: CONTROL, label: SDK_NOT_READY };
 
-function treatmentsNotReady(splitNames: string[]) {
+function treatmentsNotReady(featureFlagNames: string[]) {
   const evaluations: Record<string, IEvaluationResult> = {};
-  splitNames.forEach(splitName => {
-    evaluations[splitName] = treatmentNotReady;
+  featureFlagNames.forEach(featureFlagName => {
+    evaluations[featureFlagName] = treatmentNotReady;
   });
   return evaluations;
 }
@@ -28,12 +28,12 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
   const { sdkReadinessManager: { readinessManager }, storage, settings, impressionsTracker, eventTracker, telemetryTracker } = params;
   const { log, mode } = settings;
 
-  function getTreatment(key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined, withConfig = false) {
+  function getTreatment(key: SplitIO.SplitKey, featureFlagName: string, attributes: SplitIO.Attributes | undefined, withConfig = false) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
 
     const wrapUp = (evaluationResult: IEvaluationResult) => {
       const queue: ImpressionDTO[] = [];
-      const treatment = processEvaluation(evaluationResult, splitName, key, attributes, withConfig, `getTreatment${withConfig ? 'withConfig' : ''}`, queue);
+      const treatment = processEvaluation(evaluationResult, featureFlagName, key, attributes, withConfig, `getTreatment${withConfig ? 'withConfig' : ''}`, queue);
       impressionsTracker.track(queue, attributes);
 
       stopTelemetryTracker(queue[0] && queue[0].label);
@@ -41,7 +41,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluation = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-      evaluateFeature(log, key, splitName, attributes, storage) :
+      evaluateFeature(log, key, featureFlagName, attributes, storage) :
       isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
         treatmentNotReady :
         Promise.resolve(treatmentNotReady); // Promisify if async
@@ -49,18 +49,18 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
   }
 
-  function getTreatmentWithConfig(key: SplitIO.SplitKey, splitName: string, attributes: SplitIO.Attributes | undefined) {
-    return getTreatment(key, splitName, attributes, true);
+  function getTreatmentWithConfig(key: SplitIO.SplitKey, featureFlagName: string, attributes: SplitIO.Attributes | undefined) {
+    return getTreatment(key, featureFlagName, attributes, true);
   }
 
-  function getTreatments(key: SplitIO.SplitKey, splitNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false) {
+  function getTreatments(key: SplitIO.SplitKey, featureFlagNames: string[], attributes: SplitIO.Attributes | undefined, withConfig = false) {
     const stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
 
     const wrapUp = (evaluationResults: Record<string, IEvaluationResult>) => {
       const queue: ImpressionDTO[] = [];
       const treatments: Record<string, SplitIO.Treatment | SplitIO.TreatmentWithConfig> = {};
-      Object.keys(evaluationResults).forEach(splitName => {
-        treatments[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, `getTreatments${withConfig ? 'withConfig' : ''}`, queue);
+      Object.keys(evaluationResults).forEach(featureFlagName => {
+        treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, attributes, withConfig, `getTreatments${withConfig ? 'withConfig' : ''}`, queue);
       });
       impressionsTracker.track(queue, attributes);
 
@@ -69,22 +69,22 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     };
 
     const evaluations = readinessManager.isReady() || readinessManager.isReadyFromCache() ?
-      evaluateFeatures(log, key, splitNames, attributes, storage) :
+      evaluateFeatures(log, key, featureFlagNames, attributes, storage) :
       isStorageSync(settings) ? // If the SDK is not ready, treatment may be incorrect due to having splits but not segments data, or storage is not connected
-        treatmentsNotReady(splitNames) :
-        Promise.resolve(treatmentsNotReady(splitNames)); // Promisify if async
+        treatmentsNotReady(featureFlagNames) :
+        Promise.resolve(treatmentsNotReady(featureFlagNames)); // Promisify if async
 
     return thenable(evaluations) ? evaluations.then((res) => wrapUp(res)) : wrapUp(evaluations);
   }
 
-  function getTreatmentsWithConfig(key: SplitIO.SplitKey, splitNames: string[], attributes: SplitIO.Attributes | undefined) {
-    return getTreatments(key, splitNames, attributes, true);
+  function getTreatmentsWithConfig(key: SplitIO.SplitKey, featureFlagNames: string[], attributes: SplitIO.Attributes | undefined) {
+    return getTreatments(key, featureFlagNames, attributes, true);
   }
 
   // Internal function
   function processEvaluation(
     evaluation: IEvaluationResult,
-    splitName: string,
+    featureFlagName: string,
     key: SplitIO.SplitKey,
     attributes: SplitIO.Attributes | undefined,
     withConfig: boolean,
@@ -95,12 +95,12 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     const bucketingKey = getBucketing(key);
 
     const { treatment, label, changeNumber, config = null } = evaluation;
-    log.info(IMPRESSION, [splitName, matchingKey, treatment, label]);
+    log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
 
-    if (validateSplitExistance(log, readinessManager, splitName, label, invokingMethodName)) {
+    if (validateSplitExistance(log, readinessManager, featureFlagName, label, invokingMethodName)) {
       log.info(IMPRESSION_QUEUEING);
       queue.push({
-        feature: splitName,
+        feature: featureFlagName,
         keyName: matchingKey,
         treatment,
         time: Date.now(),

package/src/sdkClient/clientAttributesDecoration.ts

@@ -18,20 +18,20 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
   const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
   const clientTrack = client.track;
 
-  function getTreatment(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
-    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatment(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes));
   }
 
-  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
-    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentWithConfig(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes));
   }
 
-  function getTreatments(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
-    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  function getTreatments(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatments(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes));
   }
 
-  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
-    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes) {
+    return clientGetTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes));
   }
 
   function track(maybeKey: SplitIO.SplitKey, maybeTT: string, maybeEvent: string, maybeEventValue?: number, maybeProperties?: SplitIO.Properties) {
@@ -60,7 +60,7 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
      * @param {string, number, boolean, list} attributeValue Attribute value
      * @returns {boolean} true if the attribute was stored and false otherways
      */
-    setAttribute(attributeName: string, attributeValue: Object) {
+    setAttribute(attributeName: string, attributeValue: SplitIO.AttributeType) {
       const attribute: Record<string, Object> = {};
       attribute[attributeName] = attributeValue;
       if (!validateAttributesDeep(log, attribute, 'setAttribute')) return false;
@@ -95,7 +95,7 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
      *
      * @returns {Object} returns all the stored attributes
      */
-    getAttributes(): Record<string, Object> {
+    getAttributes() {
       return attributeStorage.getAll();
     },
 

package/src/sdkClient/clientInputValidation.ts

@@ -30,10 +30,10 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
   /**
    * Avoid repeating this validations code
    */
-  function validateEvaluationParams(maybeKey: SplitIO.SplitKey, maybeSplitOrSplits: string | string[], maybeAttributes: SplitIO.Attributes | undefined, methodName: string) {
+  function validateEvaluationParams(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNameOrNames: string | string[], maybeAttributes: SplitIO.Attributes | undefined, methodName: string) {
     const multi = startsWith(methodName, 'getTreatments');
     const key = validateKey(log, maybeKey, methodName);
-    const splitOrSplits = multi ? validateSplits(log, maybeSplitOrSplits, methodName) : validateSplit(log, maybeSplitOrSplits, methodName);
+    const splitOrSplits = multi ? validateSplits(log, maybeFeatureFlagNameOrNames, methodName) : validateSplit(log, maybeFeatureFlagNameOrNames, methodName);
     const attributes = validateAttributes(log, maybeAttributes, methodName);
     const isOperational = validateIfNotDestroyed(log, readinessManager, methodName);
 
@@ -53,8 +53,8 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     return isSync ? value : Promise.resolve(value);
   }
 
-  function getTreatment(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatment');
+  function getTreatment(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes) {
+    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, 'getTreatment');
 
     if (params.valid) {
       return client.getTreatment(params.key as SplitIO.SplitKey, params.splitOrSplits as string, params.attributes as SplitIO.Attributes | undefined);
@@ -63,8 +63,8 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     }
   }
 
-  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeSplit: string, maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatmentWithConfig');
+  function getTreatmentWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagName: string, maybeAttributes?: SplitIO.Attributes) {
+    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, 'getTreatmentWithConfig');
 
     if (params.valid) {
       return client.getTreatmentWithConfig(params.key as SplitIO.SplitKey, params.splitOrSplits as string, params.attributes as SplitIO.Attributes | undefined);
@@ -73,8 +73,8 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     }
   }
 
-  function getTreatments(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatments');
+  function getTreatments(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes) {
+    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, 'getTreatments');
 
     if (params.valid) {
       return client.getTreatments(params.key as SplitIO.SplitKey, params.splitOrSplits as string[], params.attributes as SplitIO.Attributes | undefined);
@@ -86,8 +86,8 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     }
   }
 
-  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeSplits: string[], maybeAttributes?: SplitIO.Attributes) {
-    const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatmentsWithConfig');
+  function getTreatmentsWithConfig(maybeKey: SplitIO.SplitKey, maybeFeatureFlagNames: string[], maybeAttributes?: SplitIO.Attributes) {
+    const params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, 'getTreatmentsWithConfig');
 
     if (params.valid) {
       return client.getTreatmentsWithConfig(params.key as SplitIO.SplitKey, params.splitOrSplits as string[], params.attributes as SplitIO.Attributes | undefined);

package/src/sdkClient/sdkClient.ts

@@ -20,9 +20,9 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
     //get the actual time elapsed in ms
     const timeElapsed = now - lastActionTime;
     //check if the time elapsed is less than desired cooldown
-    if (timeElapsed < time){
+    if (timeElapsed < time) {
       //if yes, return message with remaining time in seconds
-      settings.log.warn(`Flush cooldown, remaining time ${(time-timeElapsed)/1000} seconds`);
+      settings.log.warn(`Flush cooldown, remaining time ${(time - timeElapsed) / 1000} seconds`);
       return Promise.resolve();
     } else {
       //Do the requested action and re-assign the lastActionTime
@@ -64,7 +64,7 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
           sdkReadinessManager.readinessManager.destroy();
           signalListener && signalListener.stop();
 
-          // Release the API Key if it is the main client
+          // Release the SDK Key if it is the main client
           if (!isSharedClient) releaseApiKey(settings.core.authorizationKey);
 
           if (uniqueKeysTracker) uniqueKeysTracker.stop();

package/src/sdkFactory/index.ts

@@ -26,7 +26,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     filterAdapterFactory } = params;
   const { log, sync: { impressionsMode } } = settings;
 
-  // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid API Key, etc.
+  // @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.
 
   // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.

package/src/sdkManager/index.ts

@@ -8,6 +8,10 @@ import { ISplit } from '../dtos/types';
 import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
 
+const SPLIT_FN_LABEL = 'split';
+const SPLITS_FN_LABEL = 'splits';
+const NAMES_FN_LABEL = 'names';
+
 function collectTreatments(splitObject: ISplit) {
   const conditions = splitObject.conditions;
   // Rollout conditions are supposed to have the entire partitions list, so we find the first one.
@@ -47,17 +51,16 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
   splits: TSplitCache,
   { readinessManager, sdkStatus }: ISdkReadinessManager
 ): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager {
-  const SPLIT_FN_LABEL = 'split';
 
   return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkStatus),
     {
       /**
-       * Get the Split object corresponding to the given split name if valid
+       * Get the feature flag object corresponding to the given feature flag name if valid
        */
-      split(maybeSplitName: string) {
-        const splitName = validateSplit(log, maybeSplitName, SPLIT_FN_LABEL);
+      split(featureFlagName: string) {
+        const splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
         if (!validateIfNotDestroyed(log, readinessManager, SPLIT_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
           return null;
         }
@@ -76,10 +79,10 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
         return objectToView(split);
       },
       /**
-       * Get the Split objects present on the factory storage
+       * Get the feature flag objects present on the factory storage
        */
       splits() {
-        if (!validateIfNotDestroyed(log, readinessManager, 'splits') || !validateIfOperational(log, readinessManager, 'splits')) {
+        if (!validateIfNotDestroyed(log, readinessManager, SPLITS_FN_LABEL) || !validateIfOperational(log, readinessManager, SPLITS_FN_LABEL)) {
           return [];
         }
         const currentSplits = splits.getAll();
@@ -89,10 +92,10 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
           objectsToViews(currentSplits);
       },
       /**
-       * Get the Split names present on the factory storage
+       * Get the feature flag names present on the factory storage
        */
       names() {
-        if (!validateIfNotDestroyed(log, readinessManager, 'names') || !validateIfOperational(log, readinessManager, 'names')) {
+        if (!validateIfNotDestroyed(log, readinessManager, NAMES_FN_LABEL) || !validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
           return [];
         }
         const splitNames = splits.getSplitNames();

package/src/services/splitApi.ts

@@ -30,6 +30,7 @@ export function splitApiFactory(
   const splitHttpClient = splitHttpClientFactory(settings, platform.getFetch, platform.getOptions);
 
   return {
+    // @TODO throw errors if health check requests fail, to log them in the Synchronizer
     getSdkAPIHealthCheck() {
       const url = `${urls.sdk}/version`;
       return splitHttpClient(url).then(() => true).catch(() => false);

package/src/services/splitHttpClient.ts

@@ -55,7 +55,7 @@ export function splitHttpClientFactory(settings: Pick<ISettings, 'log' | 'versio
 
         if (resp) { // An HTTP error
           switch (resp.status) {
-            case 404: msg = 'Invalid API key or resource not found.';
+            case 404: msg = 'Invalid SDK key or resource not found.';
               break;
             // Don't use resp.statusText since reason phrase is removed in HTTP/2
             default: msg = error.message;

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -41,10 +41,8 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   private _decrementCounts(split: ISplit | null) {
     try {
       if (split) {
-        if (split.trafficTypeName) {
-          const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-          this._decrementCount(ttKey);
-        }
+        const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        this._decrementCount(ttKey);
 
         if (usesSegments(split)) {
           const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
@@ -59,11 +57,9 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   private _incrementCounts(split: ISplit) {
     try {
       if (split) {
-        if (split.trafficTypeName) {
-          const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-          // @ts-expect-error
-          localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
-        }
+        const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+        // @ts-expect-error
+        localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
 
         if (usesSegments(split)) {
           const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
@@ -104,11 +100,11 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       const splitKey = this.keys.buildSplitKey(name);
       const splitFromLocalStorage = localStorage.getItem(splitKey);
       const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
-      this._decrementCounts(previousSplit);
 
       localStorage.setItem(splitKey, JSON.stringify(split));
 
       this._incrementCounts(split);
+      this._decrementCounts(previousSplit);
 
       return true;
     } catch (e) {

package/src/storages/inMemory/AttributesCacheInMemory.ts

@@ -1,8 +1,9 @@
+import { SplitIO } from '../../types';
 import { objectAssign } from '../../utils/lang/objectAssign';
 
 export class AttributesCacheInMemory {
 
-  private attributesCache: Record<string, Object> = {};
+  private attributesCache: Record<string, SplitIO.AttributeType> = {};
 
 
   /**
@@ -12,7 +13,7 @@ export class AttributesCacheInMemory {
    * @param {Object} attributeValue attribute value
    * @returns {boolean} the attribute was stored
    */
-  setAttribute(attributeName: string, attributeValue: Object): boolean {
+  setAttribute(attributeName: string, attributeValue: SplitIO.AttributeType) {
     this.attributesCache[attributeName] = attributeValue;
     return true;
   }
@@ -23,7 +24,7 @@ export class AttributesCacheInMemory {
    * @param {string} attributeName attribute name
    * @returns {Object?} stored attribute value
    */
-  getAttribute(attributeName: string): Object {
+  getAttribute(attributeName: string) {
     return this.attributesCache[attributeName];
   }
 
@@ -33,7 +34,7 @@ export class AttributesCacheInMemory {
    * @param {[string, Object]} attributes attributes to create or update
    * @returns {boolean} attributes were stored
    */
-  setAttributes(attributes: Record<string, Object>): boolean {
+  setAttributes(attributes: Record<string, Object>) {
     this.attributesCache = objectAssign(this.attributesCache, attributes);
     return true;
   }
@@ -43,7 +44,7 @@ export class AttributesCacheInMemory {
    *
    * @returns {Map<string, Object>} stored attributes
    */
-  getAll(): Record<string, Object> {
+  getAll() {
     return this.attributesCache;
   }
 
@@ -53,7 +54,7 @@ export class AttributesCacheInMemory {
    * @param {string} attributeName attribute to remove
    * @returns {boolean} attribute removed
    */
-  removeAttribute(attributeName: string): boolean {
+  removeAttribute(attributeName: string) {
     if (Object.keys(this.attributesCache).indexOf(attributeName) >= 0) {
       delete this.attributesCache[attributeName];
       return true;

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -24,11 +24,9 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     const previousSplit = this.getSplit(name);
     if (previousSplit) { // We had this Split already
 
-      if (previousSplit.trafficTypeName) {
-        const previousTtName = previousSplit.trafficTypeName;
-        this.ttCache[previousTtName]--;
-        if (!this.ttCache[previousTtName]) delete this.ttCache[previousTtName];
-      }
+      const previousTtName = previousSplit.trafficTypeName;
+      this.ttCache[previousTtName]--;
+      if (!this.ttCache[previousTtName]) delete this.ttCache[previousTtName];
 
       if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
         this.splitsWithSegmentsCount--;
@@ -40,10 +38,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.splitsCache[name] = split;
       // Update TT cache
       const ttName = split.trafficTypeName;
-      if (ttName) { // safeguard
-        if (!this.ttCache[ttName]) this.ttCache[ttName] = 0;
-        this.ttCache[ttName]++;
-      }
+      this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
 
       // Add to segments count for the new version of the Split
       if (usesSegments(split)) this.splitsWithSegmentsCount++;
@@ -61,11 +56,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       delete this.splitsCache[name];
 
       const ttName = split.trafficTypeName;
-
-      if (ttName) { // safeguard
-        this.ttCache[ttName]--; // Update tt cache
-        if (!this.ttCache[ttName]) delete this.ttCache[ttName];
-      }
+      this.ttCache[ttName]--; // Update tt cache
+      if (!this.ttCache[ttName]) delete this.ttCache[ttName];
 
       // Update the segments count.
       if (usesSegments(split)) this.splitsWithSegmentsCount--;

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -45,19 +45,15 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   }
 
   private _decrementCounts(split: ISplit) {
-    if (split.trafficTypeName) {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      return this.redis.decr(ttKey).then(count => {
-        if (count === 0) return this.redis.del(ttKey);
-      });
-    }
+    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+    return this.redis.decr(ttKey).then(count => {
+      if (count === 0) return this.redis.del(ttKey);
+    });
   }
 
   private _incrementCounts(split: ISplit) {
-    if (split.trafficTypeName) {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      return this.redis.incr(ttKey);
-    }
+    const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+    return this.redis.incr(ttKey);
   }
 
   /**
@@ -70,21 +66,24 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
     return this.redis.get(splitKey).then(splitFromStorage => {
 
       // handling parsing errors
-      let parsedPreviousSplit, newStringifiedSplit;
+      let parsedPreviousSplit: ISplit, newStringifiedSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
         newStringifiedSplit = JSON.stringify(split);
       } catch (e) {
-        throw new Error('Error parsing split definition: ' + e);
+        throw new Error('Error parsing feature flag definition: ' + e);
       }
 
-      return Promise.all([
-        this.redis.set(splitKey, newStringifiedSplit),
-        this._incrementCounts(split),
-        // If it's an update, we decrement the traffic type of the existing split,
-        parsedPreviousSplit && this._decrementCounts(parsedPreviousSplit)
-      ]);
-    }).then(([status]) => status === 'OK');
+      return this.redis.set(splitKey, newStringifiedSplit).then(() => {
+        // avoid unnecessary increment/decrement operations
+        if (parsedPreviousSplit && parsedPreviousSplit.trafficTypeName === split.trafficTypeName) return;
+
+        // update traffic type counts
+        return this._incrementCounts(split).then(() => {
+          if (parsedPreviousSplit) return this._decrementCounts(parsedPreviousSplit);
+        });
+      });
+    }).then(() => true);
   }
 
   /**
@@ -247,7 +246,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
         return Promise.resolve(splits);
       })
       .catch(e => {
-        this.log.error(LOG_PREFIX + `Could not grab splits due to an error: ${e}.`);
+        this.log.error(LOG_PREFIX + `Could not grab feature flags due to an error: ${e}.`);
         return Promise.reject(e);
       });
   }