@splitsoftware/splitio-commons 1.13.2-rc.7 → 1.13.2-rc.9

package/esm/evaluator/matchers/eq_set.js

@@ -1,5 +1,6 @@
+import { ENGINE_MATCHER_EQUAL_TO_SET } from '../../logger/constants';
 import { findIndex } from '../../utils/lang';
-export function equalToSetMatcherContext(ruleAttr) {
+export function equalToSetMatcherContext(log, ruleAttr) {
     return function equalToSetMatcher(runtimeAttr) {
         // Length being the same is the first condition.
         var isEqual = runtimeAttr.length === ruleAttr.length;
@@ -11,6 +12,7 @@ export function equalToSetMatcherContext(ruleAttr) {
         for (var i = 0; i < runtimeAttr.length && isEqual; i++) {
             _loop_1(i);
         }
+        log.debug(ENGINE_MATCHER_EQUAL_TO_SET, [runtimeAttr, ruleAttr, isEqual]);
         return isEqual;
     };
 }

package/esm/evaluator/matchers/ew.js

@@ -1,7 +1,9 @@
+import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';
 import { endsWith } from '../../utils/lang';
-export function endsWithMatcherContext(ruleAttr) {
+export function endsWithMatcherContext(log, ruleAttr) {
     return function endsWithMatcher(runtimeAttr) {
         var strEndsWith = ruleAttr.some(function (e) { return endsWith(runtimeAttr, e); });
+        log.debug(ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, strEndsWith]);
         return strEndsWith;
     };
 }

package/esm/evaluator/matchers/gte.js

@@ -1,6 +1,8 @@
-export function greaterThanEqualMatcherContext(ruleAttr) {
+import { ENGINE_MATCHER_GREATER } from '../../logger/constants';
+export function greaterThanEqualMatcherContext(log, ruleAttr) {
     return function greaterThanEqualMatcher(runtimeAttr) {
         var isGreaterThanEqual = runtimeAttr >= ruleAttr;
+        log.debug(ENGINE_MATCHER_GREATER, [runtimeAttr, ruleAttr, isGreaterThanEqual]);
         return isGreaterThanEqual;
     };
 }

package/esm/evaluator/matchers/index.js

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

package/esm/evaluator/matchers/lte.js

@@ -1,6 +1,8 @@
-export function lessThanEqualMatcherContext(ruleAttr) {
+import { ENGINE_MATCHER_LESS } from '../../logger/constants';
+export function lessThanEqualMatcherContext(log, ruleAttr) {
     return function lessThanEqualMatcher(runtimeAttr) {
         var isLessThanEqual = runtimeAttr <= ruleAttr;
+        log.debug(ENGINE_MATCHER_LESS, [runtimeAttr, ruleAttr, isLessThanEqual]);
         return isLessThanEqual;
     };
 }

package/esm/evaluator/matchers/part_of.js

@@ -1,5 +1,6 @@
 import { findIndex } from '../../utils/lang';
-export function partOfSetMatcherContext(ruleAttr) {
+import { ENGINE_MATCHER_PART_OF } from '../../logger/constants';
+export function partOfSetMatcherContext(log, ruleAttr) {
     return function partOfMatcher(runtimeAttr) {
         // To be part of the length should be minor or equal.
         var isPartOf = runtimeAttr.length <= ruleAttr.length;
@@ -11,6 +12,7 @@ export function partOfSetMatcherContext(ruleAttr) {
         for (var i = 0; i < runtimeAttr.length && isPartOf; i++) {
             _loop_1(i);
         }
+        log.debug(ENGINE_MATCHER_PART_OF, [runtimeAttr, ruleAttr, isPartOf]);
         return isPartOf;
     };
 }

package/esm/evaluator/matchers/segment.js

@@ -1,12 +1,17 @@
 import { thenable } from '../../utils/promise/thenable';
-export function segmentMatcherContext(segmentName, storage) {
+import { ENGINE_MATCHER_SEGMENT } from '../../logger/constants';
+export function segmentMatcherContext(log, segmentName, storage) {
     return function segmentMatcher(key) {
         var isInSegment = storage.segments.isInSegment(segmentName, key);
         if (thenable(isInSegment)) {
             isInSegment.then(function (result) {
+                log.debug(ENGINE_MATCHER_SEGMENT, [segmentName, key, isInSegment]);
                 return result;
             });
         }
+        else {
+            log.debug(ENGINE_MATCHER_SEGMENT, [segmentName, key, isInSegment]);
+        }
         return isInSegment;
     };
 }

package/esm/evaluator/matchers/semver_between.js

@@ -1,5 +1,5 @@
 import { Semver } from '../../utils/Semver';
-export function betweenSemverMatcherContext(ruleAttr) {
+export function betweenSemverMatcherContext(log, ruleAttr) {
     var startSemver = new Semver(ruleAttr.start);
     var endSemver = new Semver(ruleAttr.end);
     return function betweenSemverMatcher(runtimeAttr) {

package/esm/evaluator/matchers/semver_eq.js

@@ -1,5 +1,5 @@
 import { Semver } from '../../utils/Semver';
-export function equalToSemverMatcherContext(ruleAttr) {
+export function equalToSemverMatcherContext(log, ruleAttr) {
     var ruleSemver = new Semver(ruleAttr);
     return function equalToSemverMatcher(runtimeAttr) {
         var runtimeSemver = new Semver(runtimeAttr);

package/esm/evaluator/matchers/semver_gte.js

@@ -1,5 +1,5 @@
 import { Semver } from '../../utils/Semver';
-export function greaterThanEqualToSemverMatcherContext(ruleAttr) {
+export function greaterThanEqualToSemverMatcherContext(log, ruleAttr) {
     var ruleSemver = new Semver(ruleAttr);
     return function greaterThanEqualToSemverMatcher(runtimeAttr) {
         var runtimeSemver = new Semver(runtimeAttr);

package/esm/evaluator/matchers/semver_inlist.js

@@ -1,6 +1,6 @@
 import { _Set } from '../../utils/lang/sets';
 import { Semver } from '../../utils/Semver';
-export function inListSemverMatcherContext(ruleAttr) {
+export function inListSemverMatcherContext(log, ruleAttr) {
     // @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');

package/esm/evaluator/matchers/semver_lte.js

@@ -1,5 +1,5 @@
 import { Semver } from '../../utils/Semver';
-export function lessThanEqualToSemverMatcherContext(ruleAttr) {
+export function lessThanEqualToSemverMatcherContext(log, ruleAttr) {
     var ruleSemver = new Semver(ruleAttr);
     return function lessThanEqualToSemverMatcher(runtimeAttr) {
         var runtimeSemver = new Semver(runtimeAttr);

package/esm/evaluator/matchers/string.js

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

package/esm/evaluator/matchers/sw.js

@@ -1,7 +1,9 @@
+import { ENGINE_MATCHER_STARTS_WITH } from '../../logger/constants';
 import { startsWith } from '../../utils/lang';
-export function startsWithMatcherContext(ruleAttr) {
+export function startsWithMatcherContext(log, ruleAttr) {
     return function startsWithMatcher(runtimeAttr) {
         var matches = ruleAttr.some(function (e) { return startsWith(runtimeAttr, e); });
+        log.debug(ENGINE_MATCHER_STARTS_WITH, [runtimeAttr, ruleAttr, matches]);
         return matches;
     };
 }

package/esm/evaluator/matchers/whitelist.js

@@ -1,8 +1,10 @@
 import { _Set } from '../../utils/lang/sets';
-export function whitelistMatcherContext(ruleAttr) {
+import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';
+export function whitelistMatcherContext(log, ruleAttr) {
     var whitelistSet = new _Set(ruleAttr);
     return function whitelistMatcher(runtimeAttr) {
         var isInWhitelist = whitelistSet.has(runtimeAttr);
+        log.debug(ENGINE_MATCHER_WHITELIST, [runtimeAttr, ruleAttr.join(','), isInWhitelist]);
         return isInWhitelist;
     };
 }

package/esm/evaluator/parser/index.js

@@ -6,7 +6,7 @@ import { conditionContext } from '../condition';
 import { ifElseIfCombinerContext } from '../combiners/ifelseif';
 import { andCombinerContext } from '../combiners/and';
 import { thenable } from '../../utils/promise/thenable';
-import { ENGINE_MATCHER_ERROR, ENGINE_MATCHER_RESULT } from '../../logger/constants';
+import { ENGINE_MATCHER_ERROR } from '../../logger/constants';
 export function parser(log, conditions, storage) {
     var predicates = [];
     for (var i = 0; i < conditions.length; i++) {
@@ -34,13 +34,10 @@ export function parser(log, conditions, storage) {
                         log.error(ENGINE_MATCHER_ERROR, [matcherDto.name, error]);
                     }
                 }
-                function handleResult(result) {
-                    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 (thenable(result)) { // @ts-ignore
+                    return result.then(function (res) { return Boolean(res ^ matcherDto.negate); });
+                } // @ts-ignore
+                return Boolean(result ^ matcherDto.negate);
             };
         });
         // if matcher's factory can't instantiate the matchers, the expressions array will be empty

package/esm/logger/constants.js

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

package/esm/logger/messages/debug.js

@@ -6,11 +6,26 @@ export var codesDebug = 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_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'],
+    [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]'],
     // SDK
     [c.CLEANUP_REGISTERING, c.LOG_PREFIX_CLEANUP + 'Registering cleanup handler %s'],
     [c.CLEANUP_DEREGISTERING, c.LOG_PREFIX_CLEANUP + 'Deregistering cleanup handler %s'],

package/esm/logger/messages/error.js

@@ -1,7 +1,7 @@
 import * as c from '../constants';
 export var codesError = [
     // evaluator
-    [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid feature flag, no valid rules or unsupported matcher type found'],
+    [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid feature flag, no valid rules or unsupported targeting rule type found'],
     [c.ENGINE_MATCHER_ERROR, c.LOG_PREFIX_ENGINE_MATCHER + '[%s] %s'],
     // SDK
     [c.ERROR_LOGLEVEL_INVALID, 'logger: Invalid Log Level - No changes to the logs will be applied.'],

package/esm/logger/messages/warn.js

@@ -3,7 +3,7 @@ import { codesError } from './error';
 export var codesWarn = 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/esm/services/splitApi.js

@@ -38,7 +38,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
         },
         fetchSplitChanges: function (since, noCache, till) {
-            var url = urls.sdk + "/splitChanges?s=" + FLAGS_SPEC + "&since=" + since + (till ? '&till=' + till : '') + (filterQueryString || '');
+            var url = urls.sdk + "/splitChanges?s=" + FLAGS_SPEC + "&since=" + since + (filterQueryString || '') + (till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
                 .catch(function (err) {
                 if (err.statusCode === 414)

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -123,7 +123,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         // when using a new split query, we must update it at the store
         if (this.updateNewFilter) {
-            this.log.info(LOG_PREFIX + 'SDK key or feature flag filter criteria was modified. Updating cache');
+            this.log.info(LOG_PREFIX + 'SDK key, flags filter criteria or flags spec version was modified. Updating cache');
             var storageHashKey = this.keys.buildHashKey();
             try {
                 localStorage.setItem(storageHashKey, this.storageHash);

package/esm/storages/pluggable/index.js

@@ -79,7 +79,7 @@ export function PluggableStorage(options) {
                 return wrapper.get(keys.buildHashKey()).then(function (hash) {
                     var currentHash = getStorageHash(settings);
                     if (hash !== currentHash) {
-                        log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key or feature flag filter criteria was modified). Clearing cache');
+                        log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
                         return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
                             return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
                         }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });

package/esm/utils/labels/index.js

@@ -5,4 +5,4 @@ export var SDK_NOT_READY = 'not ready';
 export var EXCEPTION = 'exception';
 export var SPLIT_ARCHIVED = 'archived';
 export var NOT_IN_SPLIT = 'not in split';
-export var UNSUPPORTED_MATCHER_TYPE = 'unsupported matcher type';
+export var UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.13.2-rc.7",
+  "version": "1.13.2-rc.9",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/evaluator/matchers/all.ts

@@ -1,6 +1,10 @@
-export function allMatcherContext() {
+import { ENGINE_MATCHER_ALL } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
 
+export function allMatcherContext(log: ILogger) {
   return function allMatcher(runtimeAttr: string): boolean {
+    log.debug(ENGINE_MATCHER_ALL);
+
     return runtimeAttr != null;
   };
 }

package/src/evaluator/matchers/between.ts

@@ -1,9 +1,13 @@
 import { IBetweenMatcherData } from '../../dtos/types';
+import { ENGINE_MATCHER_BETWEEN } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
 
-export function betweenMatcherContext(ruleVO: IBetweenMatcherData) {
-
+export function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData) {
   return function betweenMatcher(runtimeAttr: number): boolean {
-    const isBetween = runtimeAttr >= ruleVO.start && runtimeAttr <= ruleVO.end;
+
+    let isBetween = runtimeAttr >= ruleVO.start && runtimeAttr <= ruleVO.end;
+
+    log.debug(ENGINE_MATCHER_BETWEEN, [runtimeAttr, ruleVO.start, ruleVO.end, isBetween]);
 
     return isBetween;
   };

package/src/evaluator/matchers/boolean.ts

@@ -1,7 +1,11 @@
-export function booleanMatcherContext(ruleAttr: boolean) {
+import { ENGINE_MATCHER_BOOLEAN } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
 
+export function booleanMatcherContext(log: ILogger, ruleAttr: boolean) {
   return function booleanMatcher(runtimeAttr: boolean): boolean {
-    const booleanMatches = ruleAttr === runtimeAttr;
+    let booleanMatches = ruleAttr === runtimeAttr;
+
+    log.debug(ENGINE_MATCHER_BOOLEAN, [ruleAttr, runtimeAttr]);
 
     return booleanMatches;
   };

package/src/evaluator/matchers/cont_all.ts

@@ -1,6 +1,8 @@
+import { ENGINE_MATCHER_CONTAINS_ALL } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export function containsAllSetMatcherContext(ruleAttr: string[]) {
+export function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function containsAllMatcher(runtimeAttr: string[]): boolean {
     let containsAll = true;
 
@@ -13,6 +15,8 @@ export function containsAllSetMatcherContext(ruleAttr: string[]) {
       }
     }
 
+    log.debug(ENGINE_MATCHER_CONTAINS_ALL, [runtimeAttr, ruleAttr, containsAll]);
+
     return containsAll;
   };
 }

package/src/evaluator/matchers/cont_any.ts

@@ -1,6 +1,8 @@
+import { ENGINE_MATCHER_CONTAINS_ANY } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export function containsAnySetMatcherContext(ruleAttr: string[]) {
+export function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function containsAnyMatcher(runtimeAttr: string[]): boolean {
     let containsAny = false;
 
@@ -8,6 +10,8 @@ export function containsAnySetMatcherContext(ruleAttr: string[]) {
       if (findIndex(runtimeAttr, e => e === ruleAttr[i]) >= 0) containsAny = true;
     }
 
+    log.debug(ENGINE_MATCHER_CONTAINS_ANY, [runtimeAttr, ruleAttr, containsAny]);
+
     return containsAny;
   };
 }

package/src/evaluator/matchers/cont_str.ts

@@ -1,8 +1,12 @@
 import { isString } from '../../utils/lang';
+import { ILogger } from '../../logger/types';
+import { ENGINE_MATCHER_CONTAINS_STRING } from '../../logger/constants';
 
-export function containsStringMatcherContext(ruleAttr: string[]) {
+export function containsStringMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function containsStringMatcher(runtimeAttr: string): boolean {
-    const contains = ruleAttr.some(e => isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1);
+    let contains = ruleAttr.some(e => isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1);
+
+    log.debug(ENGINE_MATCHER_CONTAINS_STRING, [runtimeAttr, ruleAttr, contains]);
 
     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({ split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync, log: ILogger) {
+export function dependencyMatcherContext(log: ILogger, { split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync) {
 
   function checkTreatment(evaluation: IEvaluation, acceptableTreatments: string[], parentName: string) {
     let matches = false;

package/src/evaluator/matchers/eq.ts

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

package/src/evaluator/matchers/eq_set.ts

@@ -1,6 +1,8 @@
+import { ENGINE_MATCHER_EQUAL_TO_SET } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export function equalToSetMatcherContext(ruleAttr: string[]) {
+export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function equalToSetMatcher(runtimeAttr: string[]): boolean {
     // Length being the same is the first condition.
     let isEqual = runtimeAttr.length === ruleAttr.length;
@@ -10,6 +12,8 @@ export function equalToSetMatcherContext(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,8 +1,12 @@
+import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
 import { endsWith } from '../../utils/lang';
 
-export function endsWithMatcherContext(ruleAttr: string[]) {
+export function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function endsWithMatcher(runtimeAttr: string): boolean {
-    const strEndsWith = ruleAttr.some(e => endsWith(runtimeAttr, e));
+    let strEndsWith = ruleAttr.some(e => endsWith(runtimeAttr, e));
+
+    log.debug(ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, strEndsWith]);
 
     return strEndsWith;
   };

package/src/evaluator/matchers/gte.ts

@@ -1,7 +1,11 @@
-export function greaterThanEqualMatcherContext(ruleAttr: number) {
+import { ENGINE_MATCHER_GREATER } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
 
+export function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number) {
   return function greaterThanEqualMatcher(runtimeAttr: number): boolean {
-    const isGreaterThanEqual = runtimeAttr >= ruleAttr;
+    let isGreaterThanEqual = runtimeAttr >= ruleAttr;
+
+    log.debug(ENGINE_MATCHER_GREATER, [runtimeAttr, ruleAttr, isGreaterThanEqual]);
 
     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](value, storage, log); // There is no index-out-of-bound exception in JavaScript
+  if (matchers[type]) matcherFn = matchers[type](log, value, storage); // There is no index-out-of-bound exception in JavaScript
   return matcherFn;
 }

package/src/evaluator/matchers/lte.ts

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

package/src/evaluator/matchers/part_of.ts

@@ -1,6 +1,8 @@
 import { findIndex } from '../../utils/lang';
+import { ILogger } from '../../logger/types';
+import { ENGINE_MATCHER_PART_OF } from '../../logger/constants';
 
-export function partOfSetMatcherContext(ruleAttr: string[]) {
+export function partOfSetMatcherContext(log: ILogger, 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;
@@ -10,6 +12,8 @@ export function partOfSetMatcherContext(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,18 +1,25 @@
 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(segmentName: string, storage: { segments: ISegmentsCacheBase }) {
+export function segmentMatcherContext(log: ILogger, 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,7 +1,8 @@
 import { IBetweenStringMatcherData } from '../../dtos/types';
+import { ILogger } from '../../logger/types';
 import { Semver } from '../../utils/Semver';
 
-export function betweenSemverMatcherContext(ruleAttr: IBetweenStringMatcherData) {
+export function betweenSemverMatcherContext(log: ILogger, ruleAttr: IBetweenStringMatcherData) {
   const startSemver = new Semver(ruleAttr.start);
   const endSemver = new Semver(ruleAttr.end);
 

package/src/evaluator/matchers/semver_eq.ts

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

package/src/evaluator/matchers/semver_gte.ts

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