logAggregator/RuleEngine.js

const fs = require('fs');
const winston = require("winston");

const logger = winston.createLogger({
    level: 'info',
    format: winston.format.combine(
        winston.format.timestamp(),
        winston.format.printf(info => {
            return `${info.timestamp} ${info.level}: ${info.message}`;
        })
    ),
    transports: [
        new winston.transports.Console(),
        new winston.transports.File({ filename: './log/RuleEngineError.log', level: 'error' }),
        new winston.transports.File({ filename: './log/Combined.log' })
    ]
});

exports.RuleEngine = class RuleEngine {
    constructor(ruleSetFiles) {
        logger.log("info", "Instantiated RulesEngine - RuleSetFiles: " + ruleSetFiles);
        this.ruleSet = {};
        if (ruleSetFiles === "*") {
            fs.readdirSync("./rules/").forEach(file => {
                if (this.reTest("/.*\.rule\.json$/", file)) {
                    logger.log("info", "Loading rule set file " + file);
                    let newRuleSet = JSON.parse(fs.readFileSync('./rules/' + file, 'utf8'));
                    logger.log("info", "Adding rule set " + Object.keys(newRuleSet)[0]);
                    this.ruleSet[Object.keys(newRuleSet)[0]] = newRuleSet[Object.keys(newRuleSet)[0]]
                }
            });
        } else if (ruleSetFiles.indexOf(",") > 1) {
            ruleSetFiles.split(",").forEach(file => {
                logger.log("info", "Loading rule set file " + file);
                let newRuleSet = JSON.parse(fs.readFileSync('./rules/' + file + '.rule.json', 'utf8'));
                logger.log("info", "Adding rule set " + Object.keys(newRuleSet)[0]);
                this.ruleSet[Object.keys(newRuleSet)[0]] = newRuleSet[Object.keys(newRuleSet)[0]]
            });
        } else {
            logger.log("info", "Loading rule set file " + ruleSetFiles);
            this.ruleSet = JSON.parse(fs.readFileSync('./rules/' + ruleSetFiles + '.rule.json', 'utf8'));
            logger.log("info", "Adding rule set " + Object.keys(this.ruleSet)[0]);
        }
    }
    processData(inputLine) {
        let inputData = inputLine.data;
        logger.log("debug", "ProcessingType " + inputLine.processingType);
        let allWhiteFilterRules = this.ruleSet[inputLine.processingType].rules;
        if (this.processLogicOr(allWhiteFilterRules, inputData)) { return (true); }
        logger.log("debug", "No white listing matched; returning false");
        return (false);
    }
    processLogicAnd(allWhiteFilterRules, inputData) {
        let retVal = true;
        logger.log("debug", "Logic AND - start");
        // if one condition is false the other one doens't need checking anymore, 
        // therefore including the retVal in the check condition of the below for loop
        for (let i = 0; (i < allWhiteFilterRules.length && retVal); i++) {
            let theWhiteFilterRule = allWhiteFilterRules[i];
            logger.log("debug", "  Logic AND - whiteFilterRule: " + JSON.stringify(theWhiteFilterRule));
            if (theWhiteFilterRule.Logic === "-") {
                if (!this.processLogicFlat(theWhiteFilterRule, inputData) && retVal === true) {
                    logger.log("debug", "    Logic AND - FLAT - Changing Result to false");
                    retVal = false;
                };
            } else if (theWhiteFilterRule.Logic === "|") {
                if (!this.processLogicOr(theWhiteFilterRule.rules, inputData) && retVal === true) {
                    logger.log("debug", "    Logic AND - OR - Changing Result to false");
                    retVal = false;
                };
            } else if (theWhiteFilterRule.Logic === "&") {
                if (!this.processLogicAnd(theWhiteFilterRule.rules, inputData) && retVal === true) {
                    logger.log("debug", "    Logic AND - AND - Changing Result to false");
                    retVal = false;
                };
            }
        };
        logger.log("debug", "Logic AND - end - result: " + retVal);
        return (retVal);
    }
    processLogicOr(allWhiteFilterRules, inputData) {
        logger.log("debug", "Logic OR - start");
        for (let i = 0; i < allWhiteFilterRules.length; i++) {
            let theWhiteFilterRule = allWhiteFilterRules[i];
            logger.log("debug", "  Logic OR - whiteFilterRule: " + JSON.stringify(theWhiteFilterRule));
            if (theWhiteFilterRule.Logic === "-") {
                if (this.processLogicFlat(theWhiteFilterRule, inputData)) {
                    logger.log("debug", "  Logic OR - FLAT - RETURNING OUT");
                    return (true);
                };
            } else if (theWhiteFilterRule.Logic === "|") {
                if (this.processLogicOr(theWhiteFilterRule.rules, inputData)) {
                    logger.log("debug", "  Logic OR - OR - RETURNING OUT");
                    return (true)
                };
            } else if (theWhiteFilterRule.Logic === "&") {
                if (this.processLogicAnd(theWhiteFilterRule.rules, inputData)) {
                    logger.log("debug", "  Logic OR - AND - RETURNING OUT");
                    return (true)
                };
            }
        };
        logger.log("debug", "Logic OR - end");
        return (false);
    }
    processLogicFlat(theWhiteFilterRule, inputData) {
        logger.log("debug", "Logic FLAT start - whiteFilterRule: " + JSON.stringify(theWhiteFilterRule));
        let isKnownComp = false;
        let retVal = false;
        
        let dataValue;
        let ruleValue;
        let sDataType = theWhiteFilterRule.dataType || "string";

        if (sDataType ==="number") {
            dataValue = Number(inputData[theWhiteFilterRule.Field]);
            ruleValue = Number(theWhiteFilterRule.Value);
        } else {
            dataValue = inputData[theWhiteFilterRule.Field];
            ruleValue = theWhiteFilterRule.Value;
        }

		try {
			if (theWhiteFilterRule.Comp === "===") {
                isKnownComp = true;
				if (dataValue === ruleValue) {retVal = true;}
			} else if (theWhiteFilterRule.Comp === "<") {
                isKnownComp = true;
                if (dataValue < ruleValue) {retVal = true;}
			} else if (theWhiteFilterRule.Comp === ">") {
				isKnownComp = true;
				if (dataValue > ruleValue) {retVal = true;}
			} else if (theWhiteFilterRule.Comp === "<=") {
				isKnownComp = true;
				if (dataValue <= ruleValue) {retVal = true;}
			} else if (theWhiteFilterRule.Comp === ">=") {
				isKnownComp = true;
				if (dataValue >= ruleValue) {retVal = true;}
			} else if (theWhiteFilterRule.Comp === "~") {
				isKnownComp = true;
				logger.log("debug", "RegexFilter: " + ruleValue + " || " + ""+dataValue.replace(/\r/g, "\\r").replace(/\n/g, "\\n"));
				retVal = this.reTest(ruleValue, dataValue);
			}
		} catch (ex) {
			logger.log("error", "LogicFlat-Error " + ex + " WhiteFilterRule: " + JSON.stringify(theWhiteFilterRule) + " InputData " + JSON.stringify(inputData));
		}

        if (!isKnownComp) {
            logger.log("error", "The configured Comp '" + theWhiteFilterRule.Comp + "' is unknown.")
        }

        if (retVal === true) {
            logger.log("debug", "Logic FLAT - Exiting out");
        }
        logger.log("debug", "Logic FLAT - end");
        return (retVal);
    }

    reTest(regex, data) {
		try {
        let match = regex.match(new RegExp('^/(.*?)/([giumy]*)$'));
        regex = new RegExp(match[1], match[2]);
		} catch (err) {
			logger.log("error","Regular Expression processing failed for RegEx " + regex + " is it in the right format?");
		}
        return regex.test(data);
    }
}