@splitsoftware/splitio-commons 2.11.1-rc.2 → 2.12.1

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

@@ -37,7 +37,7 @@ export function SplitsUpdateWorker(log, storage, splitsSyncTask, splitsEventEmit
                             segmentsSyncTask.execute(true);
                         var attempts = backoff.attempts + 1;
                         if (ff.isSync() && rbs.isSync()) {
-                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
+                            log.debug("Refresh completed".concat(cdnBypass ? ' bypassing the CDN' : '', " in ").concat(attempts, " attempts."));
                             isHandlingEvent = false;
                             return;
                         }
@@ -46,7 +46,7 @@ export function SplitsUpdateWorker(log, storage, splitsSyncTask, splitsEventEmit
                             return;
                         }
                         if (cdnBypass) {
-                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
+                            log.debug("No changes fetched after ".concat(attempts, " attempts with CDN bypassed."));
                             isHandlingEvent = false;
                         }
                         else {

package/esm/sync/streaming/parseUtils.js

@@ -27,7 +27,7 @@ function decompress(data, compression) {
         return algorithms.gunzipSync(binData);
     if (compression === ZLIB)
         return algorithms.unzlibSync(binData);
-    throw new Error("Invalid compression algorithm #" + compression);
+    throw new Error("Invalid compression algorithm #".concat(compression));
 }
 /**
  * Decode, decompress and parse the provided 'data' into a KeyList object

package/esm/sync/submitters/submitter.js

@@ -13,7 +13,7 @@ export function submitterFactory(log, postClient, sourceCache, postRate, fromCac
         if (sourceCache.isEmpty() && !data)
             return Promise.resolve();
         data = sourceCache.pop(data);
-        var dataCountMessage = typeof data.length === 'number' ? data.length + " " + dataName : dataName;
+        var dataCountMessage = typeof data.length === 'number' ? "".concat(data.length, " ").concat(dataName) : dataName;
         log[debugLogs ? 'debug' : 'info'](SUBMITTERS_PUSH, [dataCountMessage]);
         var jsonPayload = JSON.stringify(fromCacheToPayload ? fromCacheToPayload(data) : data);
         if (!maxRetries)

package/esm/trackers/eventTracker.js

@@ -9,26 +9,24 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
  * @param eventsCache - cache to save events
  * @param integrationsManager - optional event handler used for integrations
  */
-export function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManager, telemetryCache) {
+export function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     function queueEventsCallback(eventData, tracked) {
         var eventTypeId = eventData.eventTypeId, trafficTypeName = eventData.trafficTypeName, key = eventData.key, value = eventData.value, timestamp = eventData.timestamp, properties = eventData.properties;
         // Logging every prop would be too much.
-        var msg = "event of type \"" + eventTypeId + "\" for traffic type \"" + trafficTypeName + "\". Key: " + key + ". Value: " + value + ". Timestamp: " + timestamp + ". " + (properties ? 'With properties.' : 'With no properties.');
+        var msg = "event of type \"".concat(eventTypeId, "\" for traffic type \"").concat(trafficTypeName, "\". Key: ").concat(key, ". Value: ").concat(value, ". Timestamp: ").concat(timestamp, ". ").concat(properties ? 'With properties.' : 'With no properties.');
         if (tracked) {
             log.info(EVENTS_TRACKER_SUCCESS, [msg]);
             if (integrationsManager) {
-                whenInit(function () {
-                    // Wrap in a timeout because we don't want it to be blocking.
-                    setTimeout(function () {
-                        // copy of event, to avoid unexpected behavior if modified by integrations
-                        var eventDataCopy = objectAssign({}, eventData);
-                        if (properties)
-                            eventDataCopy.properties = objectAssign({}, properties);
-                        // integrationsManager does not throw errors (they are internally handled by each integration module)
-                        integrationsManager.handleEvent(eventDataCopy);
-                    });
+                // Wrap in a timeout because we don't want it to be blocking.
+                setTimeout(function () {
+                    // copy of event, to avoid unexpected behavior if modified by integrations
+                    var eventDataCopy = objectAssign({}, eventData);
+                    if (properties)
+                        eventDataCopy.properties = objectAssign({}, properties);
+                    // integrationsManager does not throw errors (they are internally handled by each integration module)
+                    integrationsManager.handleEvent(eventDataCopy);
                 });
             }
         }

package/esm/trackers/impressionObserver/buildKey.js

@@ -1,3 +1,3 @@
 export function buildKey(impression) {
-    return impression.keyName + ":" + impression.feature + ":" + impression.treatment + ":" + impression.label + ":" + impression.changeNumber;
+    return "".concat(impression.keyName, ":").concat(impression.feature, ":").concat(impression.treatment, ":").concat(impression.label, ":").concat(impression.changeNumber);
 }

package/esm/trackers/impressionsTracker.js

@@ -1,13 +1,32 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { IMPRESSIONS_TRACKER_SUCCESS, ERROR_IMPRESSIONS_TRACKER, ERROR_IMPRESSIONS_LISTENER } from '../logger/constants';
-import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
+import { CONSENT_DECLINED, DEBUG, DEDUPED, OPTIMIZED, QUEUED } from '../utils/constants';
+import { strategyDebugFactory } from './strategy/strategyDebug';
+import { strategyNoneFactory } from './strategy/strategyNone';
+import { strategyOptimizedFactory } from './strategy/strategyOptimized';
+import { uniqueKeysTrackerFactory } from './uniqueKeysTracker';
 /**
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  */
-export function impressionsTrackerFactory(settings, impressionsCache, noneStrategy, strategy, whenInit, integrationsManager, telemetryCache) {
-    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
+export function impressionsTrackerFactory(params, storage, integrationsManager) {
+    var settings = params.settings, impressionsObserverFactory = params.impressionsObserverFactory, filterAdapterFactory = params.filterAdapterFactory;
+    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version, impressionsMode = settings.sync.impressionsMode;
+    var observer = impressionsObserverFactory();
+    var uniqueKeysTracker = uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory());
+    var noneStrategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
+    var strategy = impressionsMode === OPTIMIZED ?
+        strategyOptimizedFactory(observer, storage.impressionCounts) :
+        impressionsMode === DEBUG ?
+            strategyDebugFactory(observer) :
+            noneStrategy;
     return {
+        start: function () {
+            uniqueKeysTracker.start();
+        },
+        stop: function () {
+            uniqueKeysTracker.stop();
+        },
         track: function (impressions, attributes) {
             if (settings.userConsent === CONSENT_DECLINED)
                 return;
@@ -20,7 +39,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, noneStrate
             var impressionsLength = impressions.length;
             var impressionsToStoreLength = impressionsToStore.length;
             if (impressionsToStoreLength) {
-                var res = impressionsCache.track(impressionsToStore.map(function (item) { return item.imp; }));
+                var res = storage.impressions.track(impressionsToStore.map(function (item) { return item.imp; }));
                 // If we're on an async storage, handle error and log it.
                 if (thenable(res)) {
                     res.then(function () {
@@ -32,9 +51,9 @@ export function impressionsTrackerFactory(settings, impressionsCache, noneStrate
                 else {
                     // Record when impressionsCache is sync only (standalone mode)
                     // @TODO we are not dropping impressions on full queue yet, so DROPPED stats are not recorded
-                    if (telemetryCache) {
-                        telemetryCache.recordImpressionStats(QUEUED, impressionsToStoreLength);
-                        telemetryCache.recordImpressionStats(DEDUPED, impressionsLength - impressionsToStoreLength);
+                    if (storage.telemetry) {
+                        storage.telemetry.recordImpressionStats(QUEUED, impressionsToStoreLength);
+                        storage.telemetry.recordImpressionStats(DEDUPED, impressionsLength - impressionsToStoreLength);
                     }
                 }
             }
@@ -49,20 +68,18 @@ export function impressionsTrackerFactory(settings, impressionsCache, noneStrate
                         hostname: hostname,
                         sdkLanguageVersion: version
                     };
-                    whenInit(function () {
-                        // Wrap in a timeout because we don't want it to be blocking.
-                        setTimeout(function () {
-                            // integrationsManager.handleImpression does not throw errors
-                            if (integrationsManager)
-                                integrationsManager.handleImpression(impressionData);
-                            try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                                if (impressionListener)
-                                    impressionListener.logImpression(impressionData);
-                            }
-                            catch (err) {
-                                log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
-                            }
-                        });
+                    // Wrap in a timeout because we don't want it to be blocking.
+                    setTimeout(function () {
+                        // integrationsManager.handleImpression does not throw errors
+                        if (integrationsManager)
+                            integrationsManager.handleImpression(impressionData);
+                        try { // @ts-ignore. An exception on the listeners should not break the SDK.
+                            if (impressionListener)
+                                impressionListener.logImpression(impressionData);
+                        }
+                        catch (err) {
+                            log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
+                        }
                     });
                 };
                 for (var i = 0; i < impressionsLength; i++) {

package/esm/trackers/uniqueKeysTracker.js

@@ -19,7 +19,7 @@ export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
-                log.debug(LOG_PREFIX_UNIQUE_KEYS_TRACKER + "The feature " + featureName + " and key " + key + " exist in the filter");
+                log.debug("".concat(LOG_PREFIX_UNIQUE_KEYS_TRACKER, "The feature ").concat(featureName, " and key ").concat(key, " exist in the filter"));
                 return;
             }
             uniqueKeysCache.track(key, featureName);

package/esm/utils/inputValidation/apiKey.js

@@ -34,7 +34,7 @@ export function validateAndTrackApiKey(log, maybeSdkKey) {
             }
         }
         else {
-            log.warn(WARN_SDK_KEY, [usedKeysMap[sdkKey] + " factory/ies with this SDK Key"]);
+            log.warn(WARN_SDK_KEY, ["".concat(usedKeysMap[sdkKey], " factory/ies with this SDK Key")]);
             usedKeysMap[sdkKey]++;
         }
     }

package/esm/utils/inputValidation/attribute.js

@@ -1,7 +1,7 @@
 import { isString, isFiniteNumber, isBoolean } from '../../utils/lang';
 export function validateAttribute(log, attributeKey, attributeValue, method) {
     if (!isString(attributeKey) || attributeKey.length === 0) {
-        log.warn(method + ": you passed an invalid attribute name, attribute name must be a non-empty string.");
+        log.warn("".concat(method, ": you passed an invalid attribute name, attribute name must be a non-empty string."));
         return false;
     }
     var isStringVal = isString(attributeValue);
@@ -9,7 +9,7 @@ export function validateAttribute(log, attributeKey, attributeValue, method) {
     var isBoolVal = isBoolean(attributeValue);
     var isArrayVal = Array.isArray(attributeValue);
     if (!(isStringVal || isFiniteVal || isBoolVal || isArrayVal)) { // If it's not of valid type.
-        log.warn(method + ": you passed an invalid attribute value for " + attributeKey + ". Acceptable types are: string, number, boolean and array of strings.");
+        log.warn("".concat(method, ": you passed an invalid attribute value for ").concat(attributeKey, ". Acceptable types are: string, number, boolean and array of strings."));
         return false;
     }
     return true;

package/esm/utils/inputValidation/isOperational.js

@@ -8,7 +8,7 @@ export function validateIfNotDestroyed(log, readinessManager, method) {
 export function validateIfReadyFromCache(log, readinessManager, method, featureFlagNameOrNames) {
     if (readinessManager.isReadyFromCache())
         return true;
-    log.warn(CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? " for feature flag " + featureFlagNameOrNames.toString() : '']);
+    log.warn(CLIENT_NOT_READY_FROM_CACHE, [method, featureFlagNameOrNames ? " for feature flag ".concat(featureFlagNameOrNames.toString()) : '']);
     return false;
 }
 // Operational means that the SDK is ready to evaluate (not destroyed and ready from cache)

package/esm/utils/lang/sets.js

@@ -10,8 +10,8 @@ export function setToArray(set) {
 export function returnSetsUnion(set, set2) {
     return new Set(setToArray(set).concat(setToArray(set2)));
 }
-export function returnDifference(list, list2) {
-    if (list === void 0) { list = []; }
-    if (list2 === void 0) { list2 = []; }
-    return list.filter(function (item) { return list2.indexOf(item) === -1; });
+export function returnDifference(list1, list2) {
+    list1 = list1 || [];
+    list2 = list2 || [];
+    return list1.filter(function (item) { return list2.indexOf(item) === -1; });
 }

package/esm/utils/promise/timeout.js

@@ -3,7 +3,7 @@ export function timeout(ms, promise) {
         return promise;
     return new Promise(function (resolve, reject) {
         var tid = setTimeout(function () {
-            reject(new Error("Operation timed out because it exceeded the configured time limit of " + ms + " ms."));
+            reject(new Error("Operation timed out because it exceeded the configured time limit of ".concat(ms, " ms.")));
         }, ms);
         promise.then(function (res) {
             clearTimeout(tid);

package/esm/utils/settingsValidation/splitFilters.js

@@ -42,14 +42,14 @@ function validateFilterType(maybeFilterType) {
  */
 function validateSplitFilter(log, type, values, maxLength) {
     // validate and remove invalid and duplicated values
-    var result = validateSplits(log, values, LOG_PREFIX_SETTINGS, type + " filter", type + " filter value");
+    var result = validateSplits(log, values, LOG_PREFIX_SETTINGS, "".concat(type, " filter"), "".concat(type, " filter value"));
     if (result) {
         if (type === 'bySet') {
             result = sanitizeFlagSets(log, result, LOG_PREFIX_SETTINGS);
         }
         // check max length
         if (result.length > maxLength)
-            throw new Error(maxLength + " unique values can be specified at most for '" + type + "' filter. You passed " + result.length + ". Please consider reducing the amount or using other filter.");
+            throw new Error("".concat(maxLength, " unique values can be specified at most for '").concat(type, "' filter. You passed ").concat(result.length, ". Please consider reducing the amount or using other filter."));
         // sort values
         result.sort();
     }

package/esm/utils/settingsValidation/url.js

@@ -12,16 +12,16 @@ var streamingEndpointMatcher = /^\/(sse|event-stream)/;
  */
 export function url(settings, target) {
     if (telemetryEndpointMatcher.test(target)) {
-        return "" + settings.urls.telemetry + target;
+        return "".concat(settings.urls.telemetry).concat(target);
     }
     if (eventsEndpointMatcher.test(target)) {
-        return "" + settings.urls.events + target;
+        return "".concat(settings.urls.events).concat(target);
     }
     if (authEndpointMatcher.test(target)) {
-        return "" + settings.urls.auth + target;
+        return "".concat(settings.urls.auth).concat(target);
     }
     if (streamingEndpointMatcher.test(target)) {
-        return "" + settings.urls.streaming + target;
+        return "".concat(settings.urls.streaming).concat(target);
     }
-    return "" + settings.urls.sdk + target;
+    return "".concat(settings.urls.sdk).concat(target);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.11.1-rc.2",
+  "version": "2.12.1",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -60,10 +60,10 @@
     "@types/ioredis": "^4.28.0",
     "@types/jest": "^27.0.0",
     "@types/lodash": "^4.14.162",
-    "@typescript-eslint/eslint-plugin": "^6.6.0",
-    "@typescript-eslint/parser": "^6.6.0",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
     "cross-env": "^7.0.2",
-    "eslint": "^8.48.0",
+    "eslint": "^8.56.0",
     "eslint-plugin-compat": "^6.0.1",
     "eslint-plugin-import": "^2.25.3",
     "eslint-plugin-tsdoc": "^0.3.0",
@@ -76,7 +76,7 @@
     "redis-server": "1.2.2",
     "rimraf": "^3.0.2",
     "ts-jest": "^27.0.5",
-    "typescript": "4.4.4"
+    "typescript": "4.7.4"
   },
   "sideEffects": false
 }

package/src/dtos/types.ts

@@ -23,7 +23,7 @@ export interface IBetweenStringMatcherData {
 }
 
 export interface IWhitelistMatcherData {
-  whitelist: string[]
+  whitelist?: string[] | null
 }
 
 export interface IInSegmentMatcherData {
@@ -41,10 +41,10 @@ export interface IDependencyMatcherData {
 
 interface ISplitMatcherBase {
   matcherType: string
-  negate: boolean
-  keySelector: null | {
+  negate?: boolean
+  keySelector?: null | {
     trafficType: string,
-    attribute: string | null
+    attribute?: string | null
   }
   userDefinedSegmentMatcherData?: null | IInSegmentMatcherData
   userDefinedLargeSegmentMatcherData?: null | IInLargeSegmentMatcherData
@@ -207,18 +207,18 @@ export interface IExcludedSegment {
 export interface IRBSegment {
   name: string,
   changeNumber: number,
-  status: 'ACTIVE' | 'ARCHIVED',
-  conditions?: ISplitCondition[],
+  status?: 'ACTIVE' | 'ARCHIVED',
+  conditions?: ISplitCondition[] | null,
   excluded?: {
     keys?: string[] | null,
     segments?: IExcludedSegment[] | null
-  }
+  } | null
 }
 
 export interface ISplit {
   name: string,
   changeNumber: number,
-  status: 'ACTIVE' | 'ARCHIVED',
+  status?: 'ACTIVE' | 'ARCHIVED',
   conditions: ISplitCondition[],
   prerequisites?: null | {
     n: string,
@@ -232,9 +232,9 @@ export interface ISplit {
   trafficAllocationSeed?: number
   configurations?: {
     [treatmentName: string]: string
-  },
-  sets?: string[],
-  impressionsDisabled?: boolean
+  } | null,
+  sets?: string[] | null,
+  impressionsDisabled?: boolean | null
 }
 
 // Split definition used in offline mode
@@ -245,13 +245,13 @@ export interface ISplitChangesResponse {
   ff?: {
     t: number,
     s?: number,
-    d: ISplit[]
-  },
+    d?: ISplit[] | null,
+  } | null,
   rbs?: {
     t: number,
     s?: number,
-    d: IRBSegment[]
-  }
+    d?: IRBSegment[] | null,
+  } | null,
 }
 
 /** Interface of the parsed JSON response of `/segmentChanges/{segmentName}` */

package/src/evaluator/condition/engineUtils.ts

@@ -18,10 +18,10 @@ export function getTreatment(log: ILogger, key: string, seed: number | undefined
 /**
  * Evaluates the traffic allocation to see if we should apply rollout conditions or not.
  */
-export function shouldApplyRollout(trafficAllocation: number, key: string, trafficAllocationSeed: number) {
+export function shouldApplyRollout(trafficAllocation: number, bucketingKey: string, trafficAllocationSeed: number) {
   // For rollout, if traffic allocation for splits is 100%, we don't need to filter it because everything should evaluate the rollout.
   if (trafficAllocation < 100) {
-    const _bucket = bucket(key, trafficAllocationSeed);
+    const _bucket = bucket(bucketingKey, trafficAllocationSeed);
 
     if (_bucket > trafficAllocation) {
       return false;

package/src/evaluator/fallbackTreatmentsCalculator/index.ts

@@ -1,50 +1,32 @@
-import { FallbackTreatmentConfiguration, Treatment, TreatmentWithConfig } from '../../../types/splitio';
+import { FallbackTreatmentConfiguration, TreatmentWithConfig } from '../../../types/splitio';
 import { CONTROL } from '../../utils/constants';
 import { isString } from '../../utils/lang';
 
-export type IFallbackTreatmentsCalculator = {
-  resolve(flagName: string, label: string): TreatmentWithConfig & { label: string };
-}
+export type IFallbackTreatmentsCalculator = (flagName: string, label?: string) => TreatmentWithConfig & { label: string };
 
 export const FALLBACK_PREFIX = 'fallback - ';
 
-export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculator {
-  private readonly fallbacks: FallbackTreatmentConfiguration;
-
-  constructor(fallbacks: FallbackTreatmentConfiguration = {}) {
-    this.fallbacks = fallbacks;
-  }
-
-  resolve(flagName: string, label: string): TreatmentWithConfig & { label: string } {
-    const treatment = this.fallbacks.byFlag?.[flagName];
-    if (treatment) {
-      return this.copyWithLabel(treatment, label);
-    }
-
-    if (this.fallbacks.global) {
-      return this.copyWithLabel(this.fallbacks.global, label);
-    }
-
-    return {
-      treatment: CONTROL,
-      config: null,
-      label,
-    };
-  }
-
-  private copyWithLabel(fallback: Treatment | TreatmentWithConfig, label: string): TreatmentWithConfig & { label: string } {
-    if (isString(fallback)) {
-      return {
-        treatment: fallback,
+export function FallbackTreatmentsCalculator(fallbacks: FallbackTreatmentConfiguration = {}): IFallbackTreatmentsCalculator {
+
+  return (flagName: string, label = '') => {
+    const fallback = fallbacks.byFlag?.[flagName] || fallbacks.global;
+
+    return fallback ?
+      isString(fallback) ?
+        {
+          treatment: fallback,
+          config: null,
+          label: `${FALLBACK_PREFIX}${label}`,
+        } :
+        {
+          treatment: fallback.treatment,
+          config: fallback.config,
+          label: `${FALLBACK_PREFIX}${label}`,
+        } :
+      {
+        treatment: CONTROL,
         config: null,
-        label: `${FALLBACK_PREFIX}${label}`,
+        label,
       };
-    }
-
-    return {
-      treatment: fallback.treatment,
-      config: fallback.config,
-      label: `${FALLBACK_PREFIX}${label}`,
-    };
-  }
+  };
 }

package/src/evaluator/matchers/whitelist.ts

@@ -1,5 +1,5 @@
-export function whitelistMatcherContext(ruleAttr: string[]) {
-  const whitelistSet = new Set(ruleAttr);
+export function whitelistMatcherContext(ruleAttr?: string[] | null) {
+  const whitelistSet = new Set(ruleAttr || []);
 
   return function whitelistMatcher(runtimeAttr: string): boolean {
     const isInWhitelist = whitelistSet.has(runtimeAttr);

package/src/evaluator/types.ts

@@ -13,8 +13,8 @@ export interface IMatcherDto {
   name: string
   value?: string | number | boolean | string[] | IDependencyMatcherData | IBetweenMatcherData | IBetweenStringMatcherData | null
 
-  attribute: string | null
-  negate: boolean
+  attribute?: string | null
+  negate?: boolean
   dataType: string
 }
 

package/src/evaluator/value/index.ts

@@ -4,7 +4,7 @@ import { ILogger } from '../../logger/types';
 import { sanitize } from './sanitize';
 import { ENGINE_VALUE, ENGINE_VALUE_NO_ATTRIBUTES, ENGINE_VALUE_INVALID } from '../../logger/constants';
 
-function parseValue(log: ILogger, key: SplitIO.SplitKey, attributeName: string | null, attributes?: SplitIO.Attributes) {
+function parseValue(log: ILogger, key: SplitIO.SplitKey, attributeName?: string | null, attributes?: SplitIO.Attributes) {
   let value = undefined;
   if (attributeName) {
     if (attributes) {

package/src/integrations/pluggable.ts

@@ -21,7 +21,7 @@ export function pluggableIntegrationsManagerFactory(
   // No need to check if `settings.integrations` is an array of functions. It was already validated
   integrations.forEach(integrationFactory => {
     let integration = integrationFactory(params);
-    if (integration && integration.queue) listeners.push(integration);
+    if (integration) listeners.push(integration);
   });
 
   // If `listeners` is empty, not return a integration manager

package/src/logger/constants.ts

@@ -32,7 +32,6 @@ export const ENGINE_DEFAULT = 41;
 
 export const CLIENT_READY_FROM_CACHE = 100;
 export const CLIENT_READY = 101;
-export const IMPRESSION = 102;
 export const IMPRESSION_QUEUEING = 103;
 export const NEW_SHARED_CLIENT = 104;
 export const NEW_FACTORY = 105;

package/src/logger/messages/info.ts

@@ -8,8 +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 +'Feature flag: %s. Key: %s. Evaluation: %s. Label: %s'],
-  [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER +'Queueing corresponding impression.'],
+  [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 Split SDK instance created. %s'],
   [c.EVENTS_TRACKER_SUCCESS, c.LOG_PREFIX_EVENTS_TRACKER + 'Successfully queued %s'],

package/src/logger/messages/warn.ts

@@ -21,9 +21,9 @@ export const codesWarn: [number, string][] = codesError.concat([
   [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_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_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 the Split user interface.'],
+  [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.'],
   // initialization / settings validation
   [c.WARN_INTEGRATION_INVALID, c.LOG_PREFIX_SETTINGS + ': %s integration item(s) at settings is invalid. %s'],
@@ -36,5 +36,5 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing %s notification: %s'],
   [c.WARN_INVALID_FLAGSET, '%s: you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
   [c.WARN_LOWERCASE_FLAGSET, '%s: flag set %s should be all lowercase - converting string to lowercase.'],
-  [c.WARN_FLAGSET_WITHOUT_FLAGS, '%s: you passed %s flag set that does not contain cached feature flag names. Please double check what flag sets are in use in the Split user interface.'],
+  [c.WARN_FLAGSET_WITHOUT_FLAGS, '%s: you passed %s flag set that does not contain cached feature flag names. Please double check what flag sets are in use in Harness FME UI.'],
 ]);

package/src/sdkClient/client.ts

@@ -7,7 +7,7 @@ import { SDK_NOT_READY } from '../utils/labels';
 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 { IEvaluationResult } from '../evaluator/types';
 import SplitIO from '../../types/splitio';
-import { IMPRESSION, IMPRESSION_QUEUEING } from '../logger/constants';
+import { IMPRESSION_QUEUEING } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { Method } from '../sync/submitters/types';
@@ -147,16 +147,14 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     let { treatment, label, config = null } = evaluation;
 
     if (treatment === CONTROL) {
-      const fallbackTreatment = fallbackTreatmentsCalculator.resolve(featureFlagName, label);
+      const fallbackTreatment = fallbackTreatmentsCalculator(featureFlagName, label);
       treatment = fallbackTreatment.treatment;
       label = fallbackTreatment.label;
       config = fallbackTreatment.config;
     }
 
-    log.info(IMPRESSION, [featureFlagName, matchingKey, treatment, label]);
-
     if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName)) {
-      log.info(IMPRESSION_QUEUEING);
+      log.info(IMPRESSION_QUEUEING, [featureFlagName, matchingKey, treatment, label]);
       queue.push({
         imp: {
           feature: featureFlagName,