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

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[]) /*: Function */ {
+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,12 +1,8 @@
-import { ENGINE_MATCHER_GREATER } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+export function greaterThanEqualMatcherContext(ruleAttr: number) {
 
-export function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: Function */ {
   return function greaterThanEqualMatcher(runtimeAttr: number): boolean {
-    let isGreaterEqualThan = runtimeAttr >= ruleAttr;
+    const isGreaterThanEqual = runtimeAttr >= ruleAttr;
 
-    log.debug(ENGINE_MATCHER_GREATER, [runtimeAttr, ruleAttr, isGreaterEqualThan]);
-
-    return isGreaterEqualThan;
+    return isGreaterThanEqual;
   };
 }

package/src/evaluator/matchers/index.ts

@@ -15,29 +15,39 @@ import { containsStringMatcherContext } from './cont_str';
 import { dependencyMatcherContext } from './dependency';
 import { booleanMatcherContext } from './boolean';
 import { stringMatcherContext } from './string';
+import { equalToSemverMatcherContext } from './semver_eq';
+import { greaterThanEqualToSemverMatcherContext } from './semver_gte';
+import { lessThanEqualToSemverMatcherContext } from './semver_lte';
+import { betweenSemverMatcherContext } from './semver_between';
+import { inListSemverMatcherContext } from './semver_inlist';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { IMatcher, IMatcherDto } from '../types';
 import { ILogger } from '../../logger/types';
 
 const matchers = [
-  undefined, // UNDEFINED: 0,
-  allMatcherContext, // ALL_KEYS: 1,
-  segmentMatcherContext, // IN_SEGMENT: 2,
-  whitelistMatcherContext, // WHITELIST: 3,
-  equalToMatcherContext, // EQUAL_TO: 4,
-  greaterThanEqualMatcherContext, // GREATER_THAN_OR_EQUAL_TO: 5,
-  lessThanEqualMatcherContext, // LESS_THAN_OR_EQUAL_TO: 6,
-  betweenMatcherContext, // BETWEEN: 7,
-  equalToSetMatcherContext, // EQUAL_TO_SET: 8,
-  containsAnySetMatcherContext, // CONTAINS_ANY_OF_SET: 9,
-  containsAllSetMatcherContext, // CONTAINS_ALL_OF_SET: 10,
-  partOfSetMatcherContext, // PART_OF_SET: 11,
-  endsWithMatcherContext, // ENDS_WITH: 12,
-  startsWithMatcherContext, // STARTS_WITH: 13,
-  containsStringMatcherContext, // CONTAINS_STRING: 14,
-  dependencyMatcherContext, // IN_SPLIT_TREATMENT: 15,
-  booleanMatcherContext, // EQUAL_TO_BOOLEAN: 16,
-  stringMatcherContext // MATCHES_STRING: 17
+  undefined, // UNDEFINED: 0
+  allMatcherContext, // ALL_KEYS: 1
+  segmentMatcherContext, // IN_SEGMENT: 2
+  whitelistMatcherContext, // WHITELIST: 3
+  equalToMatcherContext, // EQUAL_TO: 4
+  greaterThanEqualMatcherContext, // GREATER_THAN_OR_EQUAL_TO: 5
+  lessThanEqualMatcherContext, // LESS_THAN_OR_EQUAL_TO: 6
+  betweenMatcherContext, // BETWEEN: 7
+  equalToSetMatcherContext, // EQUAL_TO_SET: 8
+  containsAnySetMatcherContext, // CONTAINS_ANY_OF_SET: 9
+  containsAllSetMatcherContext, // CONTAINS_ALL_OF_SET: 10
+  partOfSetMatcherContext, // PART_OF_SET: 11
+  endsWithMatcherContext, // ENDS_WITH: 12
+  startsWithMatcherContext, // STARTS_WITH: 13
+  containsStringMatcherContext, // CONTAINS_STRING: 14
+  dependencyMatcherContext, // IN_SPLIT_TREATMENT: 15
+  booleanMatcherContext, // EQUAL_TO_BOOLEAN: 16
+  stringMatcherContext, // MATCHES_STRING: 17
+  equalToSemverMatcherContext, // EQUAL_TO_SEMVER: 18
+  greaterThanEqualToSemverMatcherContext, // GREATER_THAN_OR_EQUAL_TO_SEMVER: 19
+  lessThanEqualToSemverMatcherContext, // LESS_THAN_OR_EQUAL_TO_SEMVER: 20
+  betweenSemverMatcherContext, // BETWEEN_SEMVER: 21
+  inListSemverMatcherContext, // IN_LIST_SEMVER: 22
 ];
 
 /**
@@ -51,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,12 +1,8 @@
-import { ENGINE_MATCHER_LESS } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+export function lessThanEqualMatcherContext(ruleAttr: number) {
 
-export function lessThanEqualMatcherContext(log: ILogger, ruleAttr: number) /*: function */ {
   return function lessThanEqualMatcher(runtimeAttr: number): boolean {
-    let isLessEqualThan = runtimeAttr <= ruleAttr;
+    const isLessThanEqual = runtimeAttr <= ruleAttr;
 
-    log.debug(ENGINE_MATCHER_LESS, [runtimeAttr, ruleAttr, isLessEqualThan]);
-
-    return isLessEqualThan;
+    return isLessThanEqual;
   };
 }

package/src/evaluator/matchers/matcherTypes.ts

@@ -16,7 +16,12 @@ export const matcherTypes: Record<string, number> = {
   CONTAINS_STRING: 14,
   IN_SPLIT_TREATMENT: 15,
   EQUAL_TO_BOOLEAN: 16,
-  MATCHES_STRING: 17
+  MATCHES_STRING: 17,
+  EQUAL_TO_SEMVER: 18,
+  GREATER_THAN_OR_EQUAL_TO_SEMVER: 19,
+  LESS_THAN_OR_EQUAL_TO_SEMVER: 20,
+  BETWEEN_SEMVER: 21,
+  IN_LIST_SEMVER: 22,
 };
 
 export const matcherDataTypes = {

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[]) /*: Function */ {
+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[]) /*: Fu
       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

@@ -0,0 +1,15 @@
+import { IBetweenStringMatcherData } from '../../dtos/types';
+import { Semver } from '../../utils/Semver';
+
+export function betweenSemverMatcherContext(ruleAttr: IBetweenStringMatcherData) {
+  const startSemver = new Semver(ruleAttr.start);
+  const endSemver = new Semver(ruleAttr.end);
+
+  return function betweenSemverMatcher(runtimeAttr: string): boolean {
+    const runtimeSemver = new Semver(runtimeAttr);
+
+    const isBetween = startSemver.compare(runtimeSemver) <= 0 && endSemver.compare(runtimeSemver) >= 0;
+
+    return isBetween;
+  };
+}

package/src/evaluator/matchers/semver_eq.ts

@@ -0,0 +1,13 @@
+import { Semver } from '../../utils/Semver';
+
+export function equalToSemverMatcherContext(ruleAttr: string) {
+  const ruleSemver = new Semver(ruleAttr);
+
+  return function equalToSemverMatcher(runtimeAttr: string): boolean {
+    const runtimeSemver = new Semver(runtimeAttr);
+
+    const isEqual = ruleSemver.version === runtimeSemver.version;
+
+    return isEqual;
+  };
+}

package/src/evaluator/matchers/semver_gte.ts

@@ -0,0 +1,13 @@
+import { Semver } from '../../utils/Semver';
+
+export function greaterThanEqualToSemverMatcherContext(ruleAttr: string) {
+  const ruleSemver = new Semver(ruleAttr);
+
+  return function greaterThanEqualToSemverMatcher(runtimeAttr: string): boolean {
+    const runtimeSemver = new Semver(runtimeAttr);
+
+    const isGreaterThanEqual = runtimeSemver.compare(ruleSemver) >= 0;
+
+    return isGreaterThanEqual;
+  };
+}

package/src/evaluator/matchers/semver_inlist.ts

@@ -0,0 +1,17 @@
+import { _Set } from '../../utils/lang/sets';
+import { Semver } from '../../utils/Semver';
+
+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');
+
+  const listOfSemvers = new _Set(ruleAttr.map((version) => new Semver(version).version));
+
+  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

@@ -0,0 +1,13 @@
+import { Semver } from '../../utils/Semver';
+
+export function lessThanEqualToSemverMatcherContext(ruleAttr: string) {
+  const ruleSemver = new Semver(ruleAttr);
+
+  return function lessThanEqualToSemverMatcher(runtimeAttr: string): boolean {
+    const runtimeSemver = new Semver(runtimeAttr);
+
+    const isLessThanEqual = runtimeSemver.compare(ruleSemver) <= 0;
+
+    return isLessThanEqual;
+  };
+}

package/src/evaluator/matchers/string.ts

@@ -1,21 +1,8 @@
-import { ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STRING } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+export function stringMatcherContext(ruleAttr: string) {
+  const regex = new RegExp(ruleAttr);
 
-export function stringMatcherContext(log: ILogger, ruleAttr: string) /*: Function */ {
   return function stringMatcher(runtimeAttr: string): boolean {
-    let re;
-
-    try {
-      re = new RegExp(ruleAttr);
-    } catch (e) {
-      log.debug(ENGINE_MATCHER_STRING_INVALID, [ruleAttr]);
-
-      return false;
-    }
-
-    let regexMatches = re.test(runtimeAttr);
-
-    log.debug(ENGINE_MATCHER_STRING, [runtimeAttr, ruleAttr, regexMatches ? 'yes' : 'no']);
+    const regexMatches = regex.test(runtimeAttr);
 
     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[]) /*: Function */ {
+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,12 +1,10 @@
-import { setToArray, ISet } from '../../utils/lang/sets';
-import { ILogger } from '../../logger/types';
-import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';
+import { _Set } from '../../utils/lang/sets';
 
-export function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>) /*: Function */ {
-  return function whitelistMatcher(runtimeAttr: string): boolean {
-    let isInWhitelist = ruleAttr.has(runtimeAttr);
+export function whitelistMatcherContext(ruleAttr: string[]) {
+  const whitelistSet = new _Set(ruleAttr);
 
-    log.debug(ENGINE_MATCHER_WHITELIST, [runtimeAttr, setToArray(ruleAttr).join(','), isInWhitelist]);
+  return function whitelistMatcher(runtimeAttr: string): boolean {
+    const isInWhitelist = whitelistSet.has(runtimeAttr);
 
     return isInWhitelist;
   };

package/src/evaluator/matchersTransform/index.ts

@@ -2,10 +2,9 @@ import { findIndex } from '../../utils/lang';
 import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/matcherTypes';
 import { segmentTransform } from './segment';
 import { whitelistTransform } from './whitelist';
-import { setTransform } from './set';
 import { numericTransform } from './unaryNumeric';
 import { zeroSinceHH, zeroSinceSS } from '../convertions';
-import { IBetweenMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData, IWhitelistMatcherData } from '../../dtos/types';
+import { IBetweenMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
 import { IMatcherDto } from '../types';
 
 /**
@@ -15,16 +14,17 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
 
   let parsedMatchers = matchers.map(matcher => {
     let {
-      matcherType                                   /* string */,
-      negate                                        /* boolean */,
-      keySelector                                   /* keySelectorObject */,
-      userDefinedSegmentMatcherData: segmentObject  /* segmentObject */,
-      whitelistMatcherData: whitelistObject         /* whiteListObject, provided by 'WHITELIST', set and string matchers */,
-      unaryNumericMatcherData: unaryNumericObject   /* unaryNumericObject */,
-      betweenMatcherData: betweenObject             /* betweenObject */,
-      dependencyMatcherData: dependencyObject       /* dependencyObject */,
+      matcherType,
+      negate,
+      keySelector,
+      userDefinedSegmentMatcherData,
+      whitelistMatcherData, /* whitelistObject, provided by 'WHITELIST', 'IN_LIST_SEMVER', set and string matchers */
+      unaryNumericMatcherData,
+      betweenMatcherData,
+      dependencyMatcherData,
       booleanMatcherData,
-      stringMatcherData
+      stringMatcherData,
+      betweenStringMatcherData
     } = matcher;
 
     let attribute = keySelector && keySelector.attribute;
@@ -34,28 +34,26 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
     let value = undefined;
 
     if (type === matcherTypes.IN_SEGMENT) {
-      value = segmentTransform(segmentObject as IInSegmentMatcherData);
-    } else if (type === matcherTypes.WHITELIST) {
-      value = whitelistTransform(whitelistObject as IWhitelistMatcherData);
+      value = segmentTransform(userDefinedSegmentMatcherData as IInSegmentMatcherData);
     } else if (type === matcherTypes.EQUAL_TO) {
-      value = numericTransform(unaryNumericObject as IUnaryNumericMatcherData);
+      value = numericTransform(unaryNumericMatcherData as IUnaryNumericMatcherData);
       dataType = matcherDataTypes.NUMBER;
 
-      if ((unaryNumericObject as IUnaryNumericMatcherData).dataType === 'DATETIME') {
+      if ((unaryNumericMatcherData as IUnaryNumericMatcherData).dataType === 'DATETIME') {
         value = zeroSinceHH(value);
         dataType = matcherDataTypes.DATETIME;
       }
     } else if (type === matcherTypes.GREATER_THAN_OR_EQUAL_TO ||
       type === matcherTypes.LESS_THAN_OR_EQUAL_TO) {
-      value = numericTransform(unaryNumericObject as IUnaryNumericMatcherData);
+      value = numericTransform(unaryNumericMatcherData as IUnaryNumericMatcherData);
       dataType = matcherDataTypes.NUMBER;
 
-      if ((unaryNumericObject as IUnaryNumericMatcherData).dataType === 'DATETIME') {
+      if ((unaryNumericMatcherData as IUnaryNumericMatcherData).dataType === 'DATETIME') {
         value = zeroSinceSS(value);
         dataType = matcherDataTypes.DATETIME;
       }
     } else if (type === matcherTypes.BETWEEN) {
-      value = betweenObject as IBetweenMatcherData;
+      value = betweenMatcherData as IBetweenMatcherData;
       dataType = matcherDataTypes.NUMBER;
 
       if (value.dataType === 'DATETIME') {
@@ -63,27 +61,36 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
         value.end = zeroSinceSS(value.end);
         dataType = matcherDataTypes.DATETIME;
       }
+    } else if (type === matcherTypes.BETWEEN_SEMVER) {
+      value = betweenStringMatcherData;
     } else if (
       type === matcherTypes.EQUAL_TO_SET ||
       type === matcherTypes.CONTAINS_ANY_OF_SET ||
       type === matcherTypes.CONTAINS_ALL_OF_SET ||
       type === matcherTypes.PART_OF_SET
     ) {
-      value = setTransform(whitelistObject as IWhitelistMatcherData);
+      value = whitelistTransform(whitelistMatcherData);
       dataType = matcherDataTypes.SET;
     } else if (
+      type === matcherTypes.WHITELIST ||
+      type === matcherTypes.IN_LIST_SEMVER ||
       type === matcherTypes.STARTS_WITH ||
       type === matcherTypes.ENDS_WITH ||
       type === matcherTypes.CONTAINS_STRING
     ) {
-      value = setTransform(whitelistObject as IWhitelistMatcherData);
+      value = whitelistTransform(whitelistMatcherData);
     } else if (type === matcherTypes.IN_SPLIT_TREATMENT) {
-      value = dependencyObject;
+      value = dependencyMatcherData;
       dataType = matcherDataTypes.NOT_SPECIFIED;
     } else if (type === matcherTypes.EQUAL_TO_BOOLEAN) {
       dataType = matcherDataTypes.BOOLEAN;
       value = booleanMatcherData;
-    } else if (type === matcherTypes.MATCHES_STRING) {
+    } else if (
+      type === matcherTypes.MATCHES_STRING ||
+      type === matcherTypes.EQUAL_TO_SEMVER ||
+      type === matcherTypes.GREATER_THAN_OR_EQUAL_TO_SEMVER ||
+      type === matcherTypes.LESS_THAN_OR_EQUAL_TO_SEMVER
+    ) {
       value = stringMatcherData;
     }
 
@@ -91,6 +98,7 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
       attribute,        // attribute over we should do the matching, undefined means 'use the key'
       negate,           // should we negate the result?
       type,             // which kind of matcher we should evaluate
+      name: matcherType,// name of the matcher for logging purposes
       value,            // metadata used for the matching
       dataType          // runtime input data type
     };

package/src/evaluator/matchersTransform/whitelist.ts

@@ -1,9 +1,8 @@
-import { IWhitelistMatcherData } from '../../dtos/types';
-import { _Set } from '../../utils/lang/sets';
+import { ISplitMatcher } from '../../dtos/types';
 
 /**
- * Extract whitelist as a set. Used by 'WHITELIST' matcher.
+ * Extract whitelist array.
  */
-export function whitelistTransform(whitelistObject: IWhitelistMatcherData) {
-  return new _Set(whitelistObject.whitelist);
+export function whitelistTransform(whitelistObject: ISplitMatcher['whitelistMatcherData']) {
+  return whitelistObject && whitelistObject.whitelist;
 }

package/src/evaluator/parser/index.ts

@@ -7,10 +7,11 @@ import { ifElseIfCombinerContext } from '../combiners/ifelseif';
 import { andCombinerContext } from '../combiners/and';
 import { thenable } from '../../utils/promise/thenable';
 import { IEvaluator, IMatcherDto, ISplitEvaluator } from '../types';
-import { ISplitCondition } from '../../dtos/types';
+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, ENGINE_MATCHER_RESULT } from '../../logger/constants';
 
 export function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
   let predicates = [];
@@ -28,24 +29,38 @@ export function parser(log: ILogger, conditions: ISplitCondition[], storage: ISt
 
     // create a set of pure functions from the matcher's dto
     const expressions = matchers.map((matcherDto: IMatcherDto) => {
-      const matcher = matcherFactory(log, matcherDto, storage);
+      let matcher: ReturnType<typeof matcherFactory>;
+      try {
+        matcher = matcherFactory(log, matcherDto, storage);
+      } catch (error) {
+        log.error(ENGINE_MATCHER_ERROR, [matcherDto.name, error]);
+      }
 
       // Evaluator function.
       return (key: string, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator) => {
         const value = sanitizeValue(log, key, matcherDto, attributes);
-        const result = value !== undefined && matcher ? matcher(value, splitEvaluator) : false;
+        let result: MaybeThenable<boolean> = false;
 
-        if (thenable(result)) {
-          // @ts-ignore
-          return result.then(res => Boolean(res ^ matcherDto.negate));
+        if (value !== undefined && matcher) {
+          try {
+            result = matcher(value, splitEvaluator);
+          } catch (error) {
+            log.error(ENGINE_MATCHER_ERROR, [matcherDto.name, error]);
+          }
         }
-        // @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);
       };
     });
 
-    // if matcher's factory can't instanciate the matchers, the expressions array
-    // will be empty
+    // if matcher's factory can't instantiate the matchers, the expressions array will be empty
     if (expressions.length === 0) {
       // reset any data collected during parsing
       predicates = [];

package/src/evaluator/types.ts

@@ -1,6 +1,5 @@
-import { IBetweenMatcherData, IDependencyMatcherData, MaybeThenable } from '../dtos/types';
+import { IBetweenMatcherData, IBetweenStringMatcherData, IDependencyMatcherData, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
-import { ISet } from '../utils/lang/sets';
 import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
 
@@ -11,7 +10,8 @@ export interface IDependencyMatcherValue {
 
 export interface IMatcherDto {
   type: number
-  value?: string | number | boolean | string[] | IDependencyMatcherData | ISet<string> | IBetweenMatcherData | null
+  name: string
+  value?: string | number | boolean | string[] | IDependencyMatcherData | IBetweenMatcherData | IBetweenStringMatcherData | null
 
   attribute: string | null
   negate: boolean

package/src/logger/constants.ts

@@ -9,25 +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_STRING_INVALID = 20;
-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;
@@ -45,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;
@@ -131,6 +115,7 @@ export const ERROR_NOT_BOOLEAN = 325;
 export const ERROR_MIN_CONFIG_PARAM = 326;
 export const ERROR_TOO_MANY_SETS = 327;
 export const ERROR_SETS_FILTER_EXCLUSIVE = 328;
+export const ENGINE_MATCHER_ERROR = 329;
 
 // Log prefixes (a.k.a. tags or categories)
 export const LOG_PREFIX_SETTINGS = 'settings';

package/src/logger/index.ts

@@ -1,6 +1,6 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ILoggerOptions, ILogger } from './types';
-import { find } from '../utils/lang';
+import { find, isObject } from '../utils/lang';
 import { LogLevel } from '../types';
 import { IMap, _Map } from '../utils/lang/maps';
 
@@ -28,7 +28,13 @@ export function isLogLevelString(str: string): str is LogLevel {
 export function _sprintf(format: string = '', args: any[] = []): string {
   let i = 0;
   return format.replace(/%s/g, function () {
-    return args[i++];
+    let arg = args[i++];
+    if (isObject(arg) || Array.isArray(arg)) {
+      try {
+        arg = JSON.stringify(arg);
+      } catch (e) { /* empty */ }
+    }
+    return arg;
   });
 }
 

package/src/logger/messages/debug.ts

@@ -7,27 +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_STRING_INVALID, c.LOG_PREFIX_ENGINE_MATCHER + '[stringMatcher] %s is an invalid regex'],
-  [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'],