Source: logging.js

/*! meta-client/modules/logging */
/*jslint
    browser, long
*/
/*global
*/
/**
 * logging module.
 *
 * @module meta-client/modules/logging
 */
import _ from "underscore";
import dates from "util-web/modules/dates";
import Logger from "js-logger";
import metaClient from "meta-client/modules/client";
import protocol from "meta-core/modules/protocol";

const DEBUG_CONSOLE_ELEMENT_ID = "logging-console";
const DEBUG_CONSOLE_ELEMENT = `<div id="${DEBUG_CONSOLE_ELEMENT_ID}" class="bg-warning overflow-auto p-3" style="height: 500px;"></div>`;
const LOG_LEVEL_PROPERTY = "data.logLevel";
const TRUNCATE_LOG_LENGTH = 1000;

const defaultHandler = Logger.createDefaultHandler();
const truncateLogMessage = function (message) {
    if (_.isString(message) === false) {
        return "";
    }
    if (TRUNCATE_LOG_LENGTH < message.length) {
        return message.substring(0, TRUNCATE_LOG_LENGTH) + `..., length=${message.length}`;
    }
    return message;
};
const debugHandler = function (consoleElement, messages, context) {
    defaultHandler(messages, context);
    if (metaClient.SEND_LOG_CTX === context.name) {
        return;
    }
    const log = document.createElement("p");
    log.classList.add("mb-0");
    log.innerText = context.name + " > " + Array.prototype.map.call(messages, function (message) {
        const messageString = (
            _.isObject(message)
            ? JSON.stringify(message)
            : message
        );
        return truncateLogMessage(messageString);
    }).join(" ");
    consoleElement.appendChild(log);
};
const logToClient = function (client, threadName, level, loggerName, messages, properties) {
    return client.log(protocol.loggingMessage({
        entry: protocol.loggingEntry({
            level,
            loggerName,
            message: messages.map(function (message) {
                const messageString = (
                    _.isObject(message)
                    ? JSON.stringify(message)
                    : message
                );
                return truncateLogMessage(messageString);
            }).join(" "),
            properties,
            threadName,
            timestamp: dates.nowDateTimeString()
        })
    }));
};
const engineHandler = function (client, messages, context) {
    defaultHandler(messages, context);
    if (metaClient.SEND_LOG_CTX === context.name) {
        return;
    }
    const messagesArray = Array.prototype.slice.call(messages);
    const properties = messagesArray.reduce(function (accumulator, message) {
        return Object.assign(accumulator, protocol.parseMessageProperties(message));
    }, {});
    const clientId = client.clientId();
    if (clientId) {
        properties.clientId = clientId;
    }
    const clientName = client.client() || "client";
    logToClient(client, clientName, context.level.name, context.name, messagesArray, properties);
};
const logging = {};

logging.newMetricCounter = function (client, name) {
    return {
        count: function () {
            client.log(protocol.loggingMessage({
                counter: name
            }));
        }
    };
};

logging.newMetricMeter = function (client, name) {
    return {
        mark: function () {
            client.log(protocol.loggingMessage({
                meter: name
            }));
        }
    };
};

logging.newMetricTimer = function (client, name) {
    return {
        time: function () {
            const request = protocol.loggingMetricTimeRequest({name});
            return client.loggingMetricTime(request).then(function (reply) {
                return {
                    stop: function () {
                        const stopRequest = protocol.loggingMetricTimeRequest({name, ref: reply.ref});
                        return client.loggingMetricTime(stopRequest);
                    }
                };
            });
        }
    };
};

logging.installDebugLogger = function () {
    const helper = document.createElement("div");
    helper.innerHTML = DEBUG_CONSOLE_ELEMENT;
    document.getElementsByTagName("body")[0].appendChild(helper.firstChild);
    Logger.setLevel(Logger.DEBUG);
    Logger.setHandler(debugHandler.bind(undefined, document.getElementById(DEBUG_CONSOLE_ELEMENT_ID)));
};

logging.installEngineLogger = function (client, logLevel = Logger.INFO) {
    Logger.setLevel(logLevel);
    Logger.setHandler(engineHandler.bind(undefined, client));
};

logging.onClientNotification = function (clientNotification) {
    const level = _.get(clientNotification, LOG_LEVEL_PROPERTY);
    if (level) {
        Logger.setLevel(Logger[level]);
    }
};

export default Object.freeze(logging);