domotz-remote-pawn/src/utils/logging/hierarchy_logger.js

Domotz Agent

var _defaultLevel = 'info';

const DOMOTZ_LEVELS = require('../logging').DOMOTZ_LEVELS;
const silence = function () {};

function HierarchyLogger(writer, name, parent, treeNode) {
    var logger = {
        _name: name,
        _assignedLevel: null,
        _inheritedLevel: parent ? parent.level() : null,
        _parent: parent,
        _treeNode: treeNode,
        _writer: writer,
        _isRoot: parent === null || parent === undefined,
    };

    logger.level = function () {
        return logger._assignedLevel || logger._inheritedLevel || _defaultLevel;
    };
    logger.isEnabledFor = function (level) {
        return DOMOTZ_LEVELS[logger.level()] >= DOMOTZ_LEVELS[level];
    };
    logger.refresh = function (oldLevel) {
        /**
         * Recalculates the current logger's level and if, it changed, rebuilds the logging functions
         */
        oldLevel = oldLevel || logger.level();
        logger._inheritedLevel = logger._parent ? logger._parent.level() : null;
        var newLevel = logger.level();
        for (var childStep in logger._treeNode) {
            if (logger._treeNode.hasOwnProperty(childStep) && childStep !== '$') {
                logger._treeNode[childStep].$.refresh();
            }
        }
        if (oldLevel !== newLevel) {
            return _buildFunctions(logger);
        }
    };
    logger.setLevel = function (newLevel) {
        var oldLevel = logger.level();
        logger._assignedLevel = newLevel;
        logger.refresh(oldLevel);
    };
    logger.isRoot = function () {
        return logger._isRoot;
    };

    logger.decorate = function (postfix) {
        return DecoratedLogger(logger, postfix);
    };

    return _buildFunctions(logger);
}

function DecoratedLogger(logger, postfix) {
    var decoratedLogger = {};
    decoratedLogger.level = logger.level;
    decoratedLogger.isEnabledFor = logger.isEnabledFor;
    decoratedLogger._name = logger._name + '.' + postfix;
    decoratedLogger._writer = logger._writer;
    decoratedLogger.decorate = function (postfix) {
        return DecoratedLogger(decoratedLogger, postfix);
    };
    return _buildFunctions(decoratedLogger);
}

function _buildFunctions(logger) {
    /**
     * This method must be called every time the logger's level changes: it calculates what the various
     * logging methods of this logger will do: either proxy `console` or ignore the call.
     * This way the runtime is extremely fast, not having to compare the log level for every call.
     *
     * This method contains an unrolled 'for' because of the subtle difference of the 'const' keyword
     * between node 0.10.x and more modern node versions (see diff with previous version)
     */
    var myLevelValue = DOMOTZ_LEVELS[logger.level()];
    logger.silent = silence;
    if (myLevelValue <= DOMOTZ_LEVELS.silly) {
        logger.silly = function () {
            return logger._writer.silly.apply(null, _calculateArgs(logger, arguments));
        };
    } else {
        logger.silly = silence;
    }
    if (myLevelValue <= DOMOTZ_LEVELS.verbose) {
        logger.verbose = function () {
            return logger._writer.verbose.apply(null, _calculateArgs(logger, arguments));
        };
    } else {
        logger.verbose = silence;
    }
    if (myLevelValue <= DOMOTZ_LEVELS.debug) {
        logger.debug = function () {
            return logger._writer.debug.apply(null, _calculateArgs(logger, arguments));
        };
    } else {
        logger.debug = silence;
    }
    if (myLevelValue <= DOMOTZ_LEVELS.info) {
        logger.info = function () {
            return logger._writer.info.apply(null, _calculateArgs(logger, arguments));
        };
    } else {
        logger.info = silence;
    }
    if (myLevelValue <= DOMOTZ_LEVELS.warn) {
        logger.warn = function () {
            return logger._writer.warn.apply(null, _calculateArgs(logger, arguments));
        };
    } else {
        logger.warn = silence;
    }
    if (myLevelValue <= DOMOTZ_LEVELS.alert) {
        logger.alert = function () {
            return logger._writer.alert.apply(null, _calculateArgs(logger, arguments));
        };
    } else {
        logger.alert = silence;
    }
    if (myLevelValue <= DOMOTZ_LEVELS.error) {
        logger.error = function () {
            return logger._writer.error.apply(null, _calculateArgs(logger, arguments));
        };
    } else {
        logger.error = silence;
    }

    return logger;
}

function _calculateArgs(logger, _arguments) {
    var args = [];
    args[0] = '<' + (logger._name || 'root') + '> ' + _arguments[0];
    for (var i = 1; i < _arguments.length; i++) {
        args.push(_arguments[i]);
    }
    return args;
}

module.exports = {
    HierarchyLogger: HierarchyLogger,
};