@splitsoftware/splitio-commons 1.13.2-rc.9 → 1.14.1-rc.0

package/src/evaluator/matchers/cont_str.ts

@@ -1,12 +1,8 @@
 import { isString } from '../../utils/lang';
-import { ILogger } from '../../logger/types';
-import { ENGINE_MATCHER_CONTAINS_STRING } from '../../logger/constants';
 
-export function containsStringMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function containsStringMatcherContext(ruleAttr: string[]) {
   return function containsStringMatcher(runtimeAttr: string): boolean {
-    let contains = ruleAttr.some(e => isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1);
-
-    log.debug(ENGINE_MATCHER_CONTAINS_STRING, [runtimeAttr, ruleAttr, contains]);
+    const contains = ruleAttr.some(e => isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1);
 
     return contains;
   };

package/src/evaluator/matchers/dependency.ts

@@ -5,7 +5,7 @@ import { thenable } from '../../utils/promise/thenable';
 import { IDependencyMatcherValue, IEvaluation, ISplitEvaluator } from '../types';
 import { ENGINE_MATCHER_DEPENDENCY, ENGINE_MATCHER_DEPENDENCY_PRE } from '../../logger/constants';
 
-export function dependencyMatcherContext(log: ILogger, { split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync) {
+export function dependencyMatcherContext({ split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync, log: ILogger) {
 
   function checkTreatment(evaluation: IEvaluation, acceptableTreatments: string[], parentName: string) {
     let matches = false;

package/src/evaluator/matchers/eq.ts

@@ -1,11 +1,7 @@
-import { ENGINE_MATCHER_EQUAL } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+export function equalToMatcherContext(ruleAttr: number) {
 
-export function equalToMatcherContext(log: ILogger, ruleAttr: number) {
   return function equalToMatcher(runtimeAttr: number): boolean {
-    let isEqual = runtimeAttr === ruleAttr;
-
-    log.debug(ENGINE_MATCHER_EQUAL, [runtimeAttr, ruleAttr, isEqual]);
+    const isEqual = runtimeAttr === ruleAttr;
 
     return isEqual;
   };

package/src/evaluator/matchers/eq_set.ts

@@ -1,8 +1,6 @@
-import { ENGINE_MATCHER_EQUAL_TO_SET } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function equalToSetMatcherContext(ruleAttr: string[]) {
   return function equalToSetMatcher(runtimeAttr: string[]): boolean {
     // Length being the same is the first condition.
     let isEqual = runtimeAttr.length === ruleAttr.length;
@@ -12,8 +10,6 @@ export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) {
       if (findIndex(ruleAttr, e => e === runtimeAttr[i]) < 0) isEqual = false;
     }
 
-    log.debug(ENGINE_MATCHER_EQUAL_TO_SET, [runtimeAttr, ruleAttr, isEqual]);
-
     return isEqual;
   };
 }

package/src/evaluator/matchers/ew.ts

@@ -1,12 +1,8 @@
-import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
 import { endsWith } from '../../utils/lang';
 
-export function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function endsWithMatcherContext(ruleAttr: string[]) {
   return function endsWithMatcher(runtimeAttr: string): boolean {
-    let strEndsWith = ruleAttr.some(e => endsWith(runtimeAttr, e));
-
-    log.debug(ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, strEndsWith]);
+    const strEndsWith = ruleAttr.some(e => endsWith(runtimeAttr, e));
 
     return strEndsWith;
   };

package/src/evaluator/matchers/gte.ts

@@ -1,11 +1,7 @@
-import { ENGINE_MATCHER_GREATER } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+export function greaterThanEqualMatcherContext(ruleAttr: number) {
 
-export function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number) {
   return function greaterThanEqualMatcher(runtimeAttr: number): boolean {
-    let isGreaterThanEqual = runtimeAttr >= ruleAttr;
-
-    log.debug(ENGINE_MATCHER_GREATER, [runtimeAttr, ruleAttr, isGreaterThanEqual]);
+    const isGreaterThanEqual = runtimeAttr >= ruleAttr;
 
     return isGreaterThanEqual;
   };

package/src/evaluator/matchers/index.ts

@@ -61,6 +61,6 @@ export function matcherFactory(log: ILogger, matcherDto: IMatcherDto, storage?:
 
   let matcherFn;
   // @ts-ignore
-  if (matchers[type]) matcherFn = matchers[type](log, value, storage); // There is no index-out-of-bound exception in JavaScript
+  if (matchers[type]) matcherFn = matchers[type](value, storage, log); // There is no index-out-of-bound exception in JavaScript
   return matcherFn;
 }

package/src/evaluator/matchers/lte.ts

@@ -1,11 +1,7 @@
-import { ENGINE_MATCHER_LESS } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+export function lessThanEqualMatcherContext(ruleAttr: number) {
 
-export function lessThanEqualMatcherContext(log: ILogger, ruleAttr: number) {
   return function lessThanEqualMatcher(runtimeAttr: number): boolean {
-    let isLessThanEqual = runtimeAttr <= ruleAttr;
-
-    log.debug(ENGINE_MATCHER_LESS, [runtimeAttr, ruleAttr, isLessThanEqual]);
+    const isLessThanEqual = runtimeAttr <= ruleAttr;
 
     return isLessThanEqual;
   };

package/src/evaluator/matchers/part_of.ts

@@ -1,8 +1,6 @@
 import { findIndex } from '../../utils/lang';
-import { ILogger } from '../../logger/types';
-import { ENGINE_MATCHER_PART_OF } from '../../logger/constants';
 
-export function partOfSetMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function partOfSetMatcherContext(ruleAttr: string[]) {
   return function partOfMatcher(runtimeAttr: string[]): boolean {
     // To be part of the length should be minor or equal.
     let isPartOf = runtimeAttr.length <= ruleAttr.length;
@@ -12,8 +10,6 @@ export function partOfSetMatcherContext(log: ILogger, ruleAttr: string[]) {
       if (findIndex(ruleAttr, e => e === runtimeAttr[i]) < 0) isPartOf = false;
     }
 
-    log.debug(ENGINE_MATCHER_PART_OF, [runtimeAttr, ruleAttr, isPartOf]);
-
     return isPartOf;
   };
 }

package/src/evaluator/matchers/segment.ts

@@ -1,25 +1,18 @@
 import { MaybeThenable } from '../../dtos/types';
 import { ISegmentsCacheBase } from '../../storages/types';
-import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
-import { ENGINE_MATCHER_SEGMENT } from '../../logger/constants';
 
-export function segmentMatcherContext(log: ILogger, segmentName: string, storage: { segments: ISegmentsCacheBase }) {
+export function segmentMatcherContext(segmentName: string, storage: { segments: ISegmentsCacheBase }) {
 
   return function segmentMatcher(key: string): MaybeThenable<boolean> {
     const isInSegment = storage.segments.isInSegment(segmentName, key);
 
     if (thenable(isInSegment)) {
       isInSegment.then(result => {
-        log.debug(ENGINE_MATCHER_SEGMENT, [segmentName, key, isInSegment]);
-
         return result;
       });
-    } else {
-      log.debug(ENGINE_MATCHER_SEGMENT, [segmentName, key, isInSegment]);
     }
 
     return isInSegment;
   };
-
 }

package/src/evaluator/matchers/semver_between.ts

@@ -1,8 +1,7 @@
 import { IBetweenStringMatcherData } from '../../dtos/types';
-import { ILogger } from '../../logger/types';
 import { Semver } from '../../utils/Semver';
 
-export function betweenSemverMatcherContext(log: ILogger, ruleAttr: IBetweenStringMatcherData) {
+export function betweenSemverMatcherContext(ruleAttr: IBetweenStringMatcherData) {
   const startSemver = new Semver(ruleAttr.start);
   const endSemver = new Semver(ruleAttr.end);
 

package/src/evaluator/matchers/semver_eq.ts

@@ -1,7 +1,6 @@
-import { ILogger } from '../../logger/types';
 import { Semver } from '../../utils/Semver';
 
-export function equalToSemverMatcherContext(log: ILogger, ruleAttr: string) {
+export function equalToSemverMatcherContext(ruleAttr: string) {
   const ruleSemver = new Semver(ruleAttr);
 
   return function equalToSemverMatcher(runtimeAttr: string): boolean {

package/src/evaluator/matchers/semver_gte.ts

@@ -1,7 +1,6 @@
-import { ILogger } from '../../logger/types';
 import { Semver } from '../../utils/Semver';
 
-export function greaterThanEqualToSemverMatcherContext(log: ILogger, ruleAttr: string) {
+export function greaterThanEqualToSemverMatcherContext(ruleAttr: string) {
   const ruleSemver = new Semver(ruleAttr);
 
   return function greaterThanEqualToSemverMatcher(runtimeAttr: string): boolean {

package/src/evaluator/matchers/semver_inlist.ts

@@ -1,8 +1,7 @@
 import { _Set } from '../../utils/lang/sets';
-import { ILogger } from '../../logger/types';
 import { Semver } from '../../utils/Semver';
 
-export function inListSemverMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function inListSemverMatcherContext(ruleAttr: string[]) {
   // @TODO ruleAttr validation should be done at the `parser` or `matchersTransform` level to reuse for all matchers
   if (!ruleAttr || ruleAttr.length === 0) throw new Error('whitelistMatcherData is required for IN_LIST_SEMVER matcher type');
 
@@ -10,6 +9,7 @@ export function inListSemverMatcherContext(log: ILogger, ruleAttr: string[]) {
 
   return function inListSemverMatcher(runtimeAttr: string): boolean {
     const runtimeSemver = new Semver(runtimeAttr).version;
+
     const isInList = listOfSemvers.has(runtimeSemver);
 
     return isInList;

package/src/evaluator/matchers/semver_lte.ts

@@ -1,7 +1,6 @@
-import { ILogger } from '../../logger/types';
 import { Semver } from '../../utils/Semver';
 
-export function lessThanEqualToSemverMatcherContext(log: ILogger, ruleAttr: string) {
+export function lessThanEqualToSemverMatcherContext(ruleAttr: string) {
   const ruleSemver = new Semver(ruleAttr);
 
   return function lessThanEqualToSemverMatcher(runtimeAttr: string): boolean {

package/src/evaluator/matchers/string.ts

@@ -1,14 +1,9 @@
-import { ENGINE_MATCHER_STRING } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-
-export function stringMatcherContext(log: ILogger, ruleAttr: string) {
+export function stringMatcherContext(ruleAttr: string) {
   const regex = new RegExp(ruleAttr);
 
   return function stringMatcher(runtimeAttr: string): boolean {
     const regexMatches = regex.test(runtimeAttr);
 
-    log.debug(ENGINE_MATCHER_STRING, [runtimeAttr, ruleAttr, regexMatches ? 'yes' : 'no']);
-
     return regexMatches;
   };
 }

package/src/evaluator/matchers/sw.ts

@@ -1,12 +1,8 @@
-import { ENGINE_MATCHER_STARTS_WITH } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
 import { startsWith } from '../../utils/lang';
 
-export function startsWithMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function startsWithMatcherContext(ruleAttr: string[]) {
   return function startsWithMatcher(runtimeAttr: string): boolean {
-    let matches = ruleAttr.some(e => startsWith(runtimeAttr, e));
-
-    log.debug(ENGINE_MATCHER_STARTS_WITH, [runtimeAttr, ruleAttr, matches]);
+    const matches = ruleAttr.some(e => startsWith(runtimeAttr, e));
 
     return matches;
   };

package/src/evaluator/matchers/whitelist.ts

@@ -1,15 +1,11 @@
 import { _Set } from '../../utils/lang/sets';
-import { ILogger } from '../../logger/types';
-import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';
 
-export function whitelistMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function whitelistMatcherContext(ruleAttr: string[]) {
   const whitelistSet = new _Set(ruleAttr);
 
   return function whitelistMatcher(runtimeAttr: string): boolean {
     const isInWhitelist = whitelistSet.has(runtimeAttr);
 
-    log.debug(ENGINE_MATCHER_WHITELIST, [runtimeAttr, ruleAttr.join(','), isInWhitelist]);
-
     return isInWhitelist;
   };
 }

package/src/evaluator/parser/index.ts

@@ -11,7 +11,7 @@ import { ISplitCondition, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
-import { ENGINE_MATCHER_ERROR } from '../../logger/constants';
+import { ENGINE_MATCHER_ERROR, ENGINE_MATCHER_RESULT } from '../../logger/constants';
 
 export function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
   let predicates = [];
@@ -49,10 +49,14 @@ export function parser(log: ILogger, conditions: ISplitCondition[], storage: ISt
           }
         }
 
-        if (thenable(result)) { // @ts-ignore
-          return result.then(res => Boolean(res ^ matcherDto.negate));
-        } // @ts-ignore
-        return Boolean(result ^ matcherDto.negate);
+        function handleResult(result: boolean) {
+          log.debug(ENGINE_MATCHER_RESULT, [matcherDto.name, result, matcherDto.value, value]); // @ts-ignore
+          return Boolean(result ^ matcherDto.negate);
+        }
+
+        return thenable(result) ?
+          result.then(handleResult) :
+          handleResult(result);
       };
     });
 

package/src/logger/constants.ts

@@ -9,24 +9,8 @@ export const ENGINE_COMBINER_AND = 0;
 export const ENGINE_COMBINER_IFELSEIF = 1;
 export const ENGINE_COMBINER_IFELSEIF_NO_TREATMENT = 2;
 export const ENGINE_BUCKET = 3;
-export const ENGINE_MATCHER_ALL = 4;
-export const ENGINE_MATCHER_BETWEEN = 5;
-export const ENGINE_MATCHER_BOOLEAN = 6;
-export const ENGINE_MATCHER_CONTAINS_ALL = 7;
-export const ENGINE_MATCHER_CONTAINS_ANY = 8;
-export const ENGINE_MATCHER_CONTAINS_STRING = 9;
 export const ENGINE_MATCHER_DEPENDENCY = 10;
 export const ENGINE_MATCHER_DEPENDENCY_PRE = 11;
-export const ENGINE_MATCHER_EQUAL = 12;
-export const ENGINE_MATCHER_EQUAL_TO_SET = 13;
-export const ENGINE_MATCHER_ENDS_WITH = 14;
-export const ENGINE_MATCHER_GREATER = 15;
-export const ENGINE_MATCHER_LESS = 16;
-export const ENGINE_MATCHER_PART_OF = 17;
-export const ENGINE_MATCHER_SEGMENT = 18;
-export const ENGINE_MATCHER_STRING = 19;
-export const ENGINE_MATCHER_STARTS_WITH = 21;
-export const ENGINE_MATCHER_WHITELIST = 22;
 export const ENGINE_VALUE = 23;
 export const ENGINE_SANITIZE = 24;
 export const CLEANUP_REGISTERING = 25;
@@ -44,6 +28,7 @@ export const SYNC_TASK_START = 36;
 export const SYNC_TASK_EXECUTE = 37;
 export const SYNC_TASK_STOP = 38;
 export const SETTINGS_SPLITS_FILTER = 39;
+export const ENGINE_MATCHER_RESULT = 40;
 
 export const CLIENT_READY_FROM_CACHE = 100;
 export const CLIENT_READY = 101;

package/src/logger/messages/debug.ts

@@ -7,26 +7,11 @@ export const codesDebug: [number, string][] = codesInfo.concat([
   [c.ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Treatment found: %s'],
   [c.ENGINE_COMBINER_IFELSEIF_NO_TREATMENT, c.LOG_PREFIX_ENGINE_COMBINER + 'All predicates evaluated, no treatment found.'],
   [c.ENGINE_BUCKET, c.LOG_PREFIX_ENGINE + ': using algo "murmur" bucket %s for key %s using seed %s - treatment %s'],
-  [c.ENGINE_MATCHER_ALL, c.LOG_PREFIX_ENGINE_MATCHER + '[allMatcher] is always true'],
-  [c.ENGINE_MATCHER_BETWEEN, c.LOG_PREFIX_ENGINE_MATCHER + '[betweenMatcher] is %s between %s and %s? %s'],
-  [c.ENGINE_MATCHER_BOOLEAN, c.LOG_PREFIX_ENGINE_MATCHER + '[booleanMatcher] %s === %s'],
-  [c.ENGINE_MATCHER_CONTAINS_ALL, c.LOG_PREFIX_ENGINE_MATCHER + '[containsAllMatcher] %s contains all elements of %s? %s'],
-  [c.ENGINE_MATCHER_CONTAINS_ANY, c.LOG_PREFIX_ENGINE_MATCHER + '[containsAnyMatcher] %s contains at least an element of %s? %s'],
-  [c.ENGINE_MATCHER_CONTAINS_STRING, c.LOG_PREFIX_ENGINE_MATCHER + '[containsStringMatcher] %s contains %s? %s'],
-  [c.ENGINE_MATCHER_DEPENDENCY, c.LOG_PREFIX_ENGINE_MATCHER + '[dependencyMatcher] parent feature flag "%s" evaluated to "%s" with label "%s". %s evaluated treatment is part of [%s] ? %s.'],
-  [c.ENGINE_MATCHER_DEPENDENCY_PRE, c.LOG_PREFIX_ENGINE_MATCHER + '[dependencyMatcher] will evaluate parent feature flag: "%s" with key: %s %s'],
-  [c.ENGINE_MATCHER_EQUAL, c.LOG_PREFIX_ENGINE_MATCHER + '[equalToMatcher] is %s equal to %s? %s'],
-  [c.ENGINE_MATCHER_EQUAL_TO_SET, c.LOG_PREFIX_ENGINE_MATCHER + '[equalToSetMatcher] is %s equal to set %s? %s'],
-  [c.ENGINE_MATCHER_ENDS_WITH, c.LOG_PREFIX_ENGINE_MATCHER + '[endsWithMatcher] %s ends with %s? %s'],
-  [c.ENGINE_MATCHER_GREATER, c.LOG_PREFIX_ENGINE_MATCHER + '[greaterThanEqualMatcher] is %s greater than %s? %s'],
-  [c.ENGINE_MATCHER_LESS, c.LOG_PREFIX_ENGINE_MATCHER + '[lessThanEqualMatcher] is %s less than %s? %s'],
-  [c.ENGINE_MATCHER_PART_OF, c.LOG_PREFIX_ENGINE_MATCHER + '[partOfMatcher] %s is part of %s? %s'],
-  [c.ENGINE_MATCHER_SEGMENT, c.LOG_PREFIX_ENGINE_MATCHER + '[segmentMatcher] evaluated %s / %s => %s'],
-  [c.ENGINE_MATCHER_STRING, c.LOG_PREFIX_ENGINE_MATCHER + '[stringMatcher] does %s matches with %s? %s'],
-  [c.ENGINE_MATCHER_STARTS_WITH, c.LOG_PREFIX_ENGINE_MATCHER + '[startsWithMatcher] %s starts with %s? %s'],
-  [c.ENGINE_MATCHER_WHITELIST, c.LOG_PREFIX_ENGINE_MATCHER + '[whitelistMatcher] evaluated %s in [%s] => %s'],
-  [c.ENGINE_VALUE, c.LOG_PREFIX_ENGINE_VALUE + 'Extracted attribute [%s], [%s] will be used for matching.'],
-  [c.ENGINE_SANITIZE, c.LOG_PREFIX_ENGINE + ':sanitize: Attempted to sanitize [%s] which should be of type [%s]. Sanitized and processed value => [%s]'],
+  [c.ENGINE_MATCHER_DEPENDENCY, c.LOG_PREFIX_ENGINE_MATCHER + '[IN_SPLIT_TREATMENT] parent feature flag "%s" evaluated to "%s" with label "%s". %s evaluated treatment is part of %s ? %s.'],
+  [c.ENGINE_MATCHER_DEPENDENCY_PRE, c.LOG_PREFIX_ENGINE_MATCHER + '[IN_SPLIT_TREATMENT] will evaluate parent feature flag: "%s" with key: %s %s'],
+  [c.ENGINE_VALUE, c.LOG_PREFIX_ENGINE_VALUE + 'Extracted attribute `%s`. %s will be used for matching.'],
+  [c.ENGINE_SANITIZE, c.LOG_PREFIX_ENGINE + ':sanitize: Attempted to sanitize %s which should be of type %s. Sanitized and processed value => %s'],
+  [c.ENGINE_MATCHER_RESULT, c.LOG_PREFIX_ENGINE_MATCHER + '[%s] Result: %s. Rule value: %s. Evaluation value: %s'],
   // SDK
   [c.CLEANUP_REGISTERING, c.LOG_PREFIX_CLEANUP + 'Registering cleanup handler %s'],
   [c.CLEANUP_DEREGISTERING, c.LOG_PREFIX_CLEANUP + 'Deregistering cleanup handler %s'],

package/src/logger/messages/warn.ts

@@ -4,7 +4,7 @@ import { codesError } from './error';
 export const codesWarn: [number, string][] = codesError.concat([
   // evaluator
   [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.'],
+  [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 feature flags. %s'],

package/src/services/splitApi.ts

@@ -4,7 +4,7 @@ import { splitHttpClientFactory } from './splitHttpClient';
 import { ISplitApi } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT, FLAGS_SPEC } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
@@ -29,6 +29,7 @@ export function splitApiFactory(
   const urls = settings.urls;
   const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
   const SplitSDKImpressionsMode = settings.sync.impressionsMode;
+  const flagSpecVersion = settings.sync.flagSpecVersion;
   const splitHttpClient = splitHttpClientFactory(settings, platform.getFetch);
 
   return {
@@ -44,7 +45,7 @@ export function splitApiFactory(
     },
 
     fetchAuth(userMatchingKeys?: string[]) {
-      let url = `${urls.auth}/v2/auth?s=${FLAGS_SPEC}`;
+      let url = `${urls.auth}/v2/auth?s=${flagSpecVersion}`;
       if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
         const queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
         if (queryParams) url += '&' + queryParams;
@@ -53,7 +54,7 @@ export function splitApiFactory(
     },
 
     fetchSplitChanges(since: number, noCache?: boolean, till?: number) {
-      const url = `${urls.sdk}/splitChanges?s=${FLAGS_SPEC}&since=${since}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
+      const url = `${urls.sdk}/splitChanges?s=${flagSpecVersion}&since=${since}${filterQueryString || ''}${till ? '&till=' + till : ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
         .catch((err) => {
           if (err.statusCode === 414) settings.log.error(ERROR_TOO_MANY_SETS);

package/src/storages/KeyBuilder.ts

@@ -1,5 +1,4 @@
 import { ISettings } from '../types';
-import { FLAGS_SPEC } from '../utils/constants';
 import { startsWith } from '../utils/lang';
 import { hash } from '../utils/murmur3/murmur3';
 
@@ -86,5 +85,5 @@ export class KeyBuilder {
  * The hash is in hexadecimal format (8 characters max, 32 bits).
  */
 export function getStorageHash(settings: ISettings) {
-  return hash(`${settings.core.authorizationKey}::${settings.sync.__splitFiltersValidation.queryString}::${FLAGS_SPEC}`).toString(16);
+  return hash(`${settings.core.authorizationKey}::${settings.sync.__splitFiltersValidation.queryString}::${settings.sync.flagSpecVersion}`).toString(16);
 }

package/src/sync/streaming/SSEClient/index.ts

@@ -4,7 +4,7 @@ import { isString } from '../../../utils/lang';
 import { IAuthTokenPushEnabled } from '../AuthClient/types';
 import { ISSEClient, ISseEventHandler } from './types';
 
-const VERSION = '1.1';
+const ABLY_API_VERSION = '1.1';
 
 const CONTROL_CHANNEL_REGEX = /^control_/;
 
@@ -78,7 +78,7 @@ export class SSEClient implements ISSEClient {
         return encodeURIComponent(params + channel);
       }
     ).join(',');
-    const url = `${this.streamingUrl}?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
+    const url = `${this.streamingUrl}?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${ABLY_API_VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
 
     this.connection = new this.eventSource!(
       // For client-side SDKs, SplitSDKClientKey and SplitSDKClientKey metadata is passed as query params,

package/src/types.ts

@@ -118,7 +118,8 @@ export interface ISettings {
     impressionsMode: SplitIO.ImpressionsMode,
     __splitFiltersValidation: ISplitFiltersValidation,
     localhostMode?: SplitIO.LocalhostFactory,
-    enabled: boolean
+    enabled: boolean,
+    flagSpecVersion: string
   },
   readonly runtime: {
     ip: string | false

package/src/utils/constants/index.ts

@@ -105,4 +105,4 @@ export const DISABLED = 0;
 export const ENABLED = 1;
 export const PAUSED = 2;
 
-export const FLAGS_SPEC = '1.1';
+export const FLAG_SPEC_VERSION = '1.1';

package/src/utils/settingsValidation/index.ts

@@ -1,7 +1,7 @@
 import { merge, get } from '../lang';
 import { validateMode } from './mode';
 import { validateSplitFilters } from './splitFilters';
-import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG } from '../constants';
+import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG, FLAG_SPEC_VERSION } from '../constants';
 import { validImpressionsMode } from './impressionsMode';
 import { ISettingsValidationParams } from './types';
 import { ISettings } from '../../types';
@@ -84,7 +84,8 @@ export const base = {
     // impressions collection mode
     impressionsMode: OPTIMIZED,
     localhostMode: undefined,
-    enabled: true
+    enabled: true,
+    flagSpecVersion: FLAG_SPEC_VERSION
   },
 
   // Logger
@@ -104,7 +105,7 @@ function fromSecondsToMillis(n: number) {
  */
 export function settingsValidation(config: unknown, validationParams: ISettingsValidationParams) {
 
-  const { defaults, runtime, storage, integrations, logger, localhost, consent } = validationParams;
+  const { defaults, runtime, storage, integrations, logger, localhost, consent, flagSpec } = validationParams;
 
   // creates a settings object merging base, defaults and config objects.
   const withDefaults = merge({}, base, defaults, config) as ISettings;
@@ -115,7 +116,8 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   withDefaults.log = log;
 
   // ensure a valid impressionsMode
-  withDefaults.sync.impressionsMode = validImpressionsMode(log, withDefaults.sync.impressionsMode);
+  const sync = withDefaults.sync;
+  sync.impressionsMode = validImpressionsMode(log, sync.impressionsMode);
 
   function validateMinValue(paramName: string, actualValue: number, minValue: number) {
     if (actualValue >= minValue) return actualValue;
@@ -133,7 +135,7 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   scheduler.telemetryRefreshRate = fromSecondsToMillis(validateMinValue('telemetryRefreshRate', scheduler.telemetryRefreshRate, 60));
 
   // Default impressionsRefreshRate for DEBUG mode is 60 secs
-  if (get(config, 'scheduler.impressionsRefreshRate') === undefined && withDefaults.sync.impressionsMode === DEBUG) scheduler.impressionsRefreshRate = 60;
+  if (get(config, 'scheduler.impressionsRefreshRate') === undefined && sync.impressionsMode === DEBUG) scheduler.impressionsRefreshRate = 60;
   scheduler.impressionsRefreshRate = fromSecondsToMillis(scheduler.impressionsRefreshRate);
 
   // Log deprecation for old telemetry param
@@ -186,25 +188,26 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // @ts-ignore, modify readonly prop
   if (integrations) withDefaults.integrations = integrations(withDefaults);
 
-  if (localhost) withDefaults.sync.localhostMode = localhost(withDefaults);
+  if (localhost) sync.localhostMode = localhost(withDefaults);
 
   // validate push options
   if (withDefaults.streamingEnabled !== false) { // @ts-ignore, modify readonly prop
     withDefaults.streamingEnabled = true;
     // Backoff bases.
-    // We are not checking if bases are positive numbers. Thus, we might be reauthenticating immediately (`setTimeout` with NaN or negative number)
+    // We are not checking if bases are positive numbers. Thus, we might be re-authenticating immediately (`setTimeout` with NaN or negative number)
     scheduler.pushRetryBackoffBase = fromSecondsToMillis(scheduler.pushRetryBackoffBase);
   }
 
   // validate sync enabled
-  if (withDefaults.sync.enabled !== false) { // @ts-ignore, modify readonly prop
-    withDefaults.sync.enabled = true;
+  if (sync.enabled !== false) {
+    sync.enabled = true;
   }
 
   // validate the `splitFilters` settings and parse splits query
-  const splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
-  withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;
-  withDefaults.sync.__splitFiltersValidation = splitFiltersValidation;
+  const splitFiltersValidation = validateSplitFilters(log, sync.splitFilters, withDefaults.mode);
+  sync.splitFilters = splitFiltersValidation.validFilters;
+  sync.__splitFiltersValidation = splitFiltersValidation;
+  sync.flagSpecVersion = flagSpec ? flagSpec(withDefaults) : FLAG_SPEC_VERSION;
 
   // ensure a valid user consent value
   // @ts-ignore, modify readonly prop

package/src/utils/settingsValidation/types.ts

@@ -26,4 +26,6 @@ export interface ISettingsValidationParams {
   localhost?: (settings: ISettings) => ISettings['sync']['localhostMode'],
   /** User consent validator (`settings.userConsent`) */
   consent: (settings: ISettings) => ISettings['userConsent'],
+  /** Flag spec version validation. Configurable by the JS Synchronizer but not by the SDKs */
+  flagSpec?: (settings: ISettings) => ISettings['sync']['flagSpecVersion']
 }

package/types/evaluator/matchers/all.d.ts

@@ -1,2 +1 @@
-import { ILogger } from '../../logger/types';
-export declare function allMatcherContext(log: ILogger): (runtimeAttr: string) => boolean;
+export declare function allMatcherContext(): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/between.d.ts

@@ -1,3 +1,2 @@
 import { IBetweenMatcherData } from '../../dtos/types';
-import { ILogger } from '../../logger/types';
-export declare function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData): (runtimeAttr: number) => boolean;
+export declare function betweenMatcherContext(ruleVO: IBetweenMatcherData): (runtimeAttr: number) => boolean;

package/types/evaluator/matchers/boolean.d.ts

@@ -1,2 +1 @@
-import { ILogger } from '../../logger/types';
-export declare function booleanMatcherContext(log: ILogger, ruleAttr: boolean): (runtimeAttr: boolean) => boolean;
+export declare function booleanMatcherContext(ruleAttr: boolean): (runtimeAttr: boolean) => boolean;

package/types/evaluator/matchers/cont_all.d.ts

@@ -1,2 +1 @@
-import { ILogger } from '../../logger/types';
-export declare function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;
+export declare function containsAllSetMatcherContext(ruleAttr: string[]): (runtimeAttr: string[]) => boolean;

package/types/evaluator/matchers/cont_any.d.ts

@@ -1,2 +1 @@
-import { ILogger } from '../../logger/types';
-export declare function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;
+export declare function containsAnySetMatcherContext(ruleAttr: string[]): (runtimeAttr: string[]) => boolean;

package/types/evaluator/matchers/cont_str.d.ts

@@ -1,2 +1 @@
-import { ILogger } from '../../logger/types';
-export declare function containsStringMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;
+export declare function containsStringMatcherContext(ruleAttr: string[]): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/dependency.d.ts

@@ -2,4 +2,4 @@ import { IDependencyMatcherData, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { ILogger } from '../../logger/types';
 import { IDependencyMatcherValue, ISplitEvaluator } from '../types';
-export declare function dependencyMatcherContext(log: ILogger, { split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync): ({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator) => MaybeThenable<boolean>;
+export declare function dependencyMatcherContext({ split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync, log: ILogger): ({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator) => MaybeThenable<boolean>;

package/types/evaluator/matchers/eq.d.ts

@@ -1,2 +1 @@
-import { ILogger } from '../../logger/types';
-export declare function equalToMatcherContext(log: ILogger, ruleAttr: number): (runtimeAttr: number) => boolean;
+export declare function equalToMatcherContext(ruleAttr: number): (runtimeAttr: number) => boolean;

package/types/evaluator/matchers/eq_set.d.ts

@@ -1,2 +1 @@
-import { ILogger } from '../../logger/types';
-export declare function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string[]) => boolean;
+export declare function equalToSetMatcherContext(ruleAttr: string[]): (runtimeAttr: string[]) => boolean;

package/types/evaluator/matchers/ew.d.ts

@@ -1,2 +1 @@
-import { ILogger } from '../../logger/types';
-export declare function endsWithMatcherContext(log: ILogger, ruleAttr: string[]): (runtimeAttr: string) => boolean;
+export declare function endsWithMatcherContext(ruleAttr: string[]): (runtimeAttr: string) => boolean;

package/types/evaluator/matchers/gte.d.ts

@@ -1,2 +1 @@
-import { ILogger } from '../../logger/types';
-export declare function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number): (runtimeAttr: number) => boolean;
+export declare function greaterThanEqualMatcherContext(ruleAttr: number): (runtimeAttr: number) => boolean;