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

Domotz Agent

const HierarchyLogger = require('./hierarchy_logger').HierarchyLogger;
const DOMOTZ_LEVELS = require('../logging').DOMOTZ_LEVELS;
var _tree = null;
var lowLevelLogger = console;
var oldConsole = null;

function registry() {
    function getLogger(path) {
        if (path === undefined || path === null || path === '') {
            path = [];
        } else {
            path = String(path).split('.');
        }
        return _getPath(path);
    }

    function setLevel(loggerName, newLevel) {
        if (DOMOTZ_LEVELS[newLevel] === undefined && newLevel !== null) {
            throw new Error('Unknown log level: ' + newLevel);
        }
        var logger = getLogger(loggerName);
        if (newLevel === null) {
            _getWriter().info("Resetting level of logger `%s` to parent's", String(loggerName));
        } else {
            _getWriter().info("Changing level of logger `%s` from '%s' to '%s'", String(loggerName), logger.level(), newLevel);
        }
        logger.setLevel(newLevel);
        if (logger.isRoot() && oldConsole !== null) {
            replaceConsoleWithRootLogger();
        }
    }

    function replaceConsoleWithWriter(logger) {
        if (oldConsole !== null) {
            throw new Error('`console` was already replaced');
        }
        lowLevelLogger = logger;
        _reset();
        replaceConsoleWithRootLogger();
    }

    function replaceConsoleWithRootLogger() {
        var rootLogger = getLogger('');
        _getWriter().info('Replacing console methods with methods from root logger, with level %s', rootLogger.level());
        oldConsole = {};
        for (var level in DOMOTZ_LEVELS) {
            if (DOMOTZ_LEVELS.hasOwnProperty(level)) {
                oldConsole[level] = console[level];
                console[level] = rootLogger.level;
            }
        }
    }

    function getStructure() {
        return _describe(_tree);
    }

    function _describe(tree) {
        var ret = {
            $: tree.$.level(),
        };
        for (var child in tree) {
            if (tree.hasOwnProperty(child) && child !== '$') {
                ret[child] = _describe(tree[child]);
            }
        }
        return ret;
    }

    function _getPath(path, index, subTree, parent) {
        if (index === undefined) {
            index = 0;
        }
        if (subTree === undefined) {
            subTree = _tree;
        }

        var currentLogger = subTree.$;
        if (currentLogger === undefined) {
            currentLogger = _buildLoggerInSubtree(path, index, parent, subTree);
        }
        if (index >= path.length) {
            return currentLogger;
        } else {
            var nextStep = path[index];
            var nextTree = subTree[nextStep];
            if (nextTree === undefined) {
                nextTree = subTree[nextStep] = {};
            }
            index++;
            return _getPath(path, index, nextTree, currentLogger);
        }
    }

    function _getWriter() {
        return lowLevelLogger;
    }

    function _buildLoggerInSubtree(path, index, parent, subTree) {
        var name = path.slice(0, index).join('.');
        subTree.$ = HierarchyLogger(lowLevelLogger, name, parent, subTree);
        return subTree.$;
    }

    return {
        getLogger: getLogger,
        setLevel: setLevel,
        replaceConsoleWithWriter: replaceConsoleWithWriter,
        getStructure: getStructure,
    };
}

function _reset() {
    _tree = {};
    _tree.$ = HierarchyLogger(lowLevelLogger, '', undefined, _tree);
    if (oldConsole !== null) {
        for (var level in DOMOTZ_LEVELS) {
            if (DOMOTZ_LEVELS.hasOwnProperty(level)) {
                console[level] = oldConsole.level;
            }
        }
        oldConsole = null;
    }
}

_reset();

module.exports = {
    registry: registry,
    // for testing purposes only
    _tree: function () {
        return _tree;
    },
    _reset: _reset,
};