@obsidize/logger/core/log-event-serializer.js

A tiny javascript logging library

import { LogLevel } from './log-level';
const defaultOptions = {
    levelNameMap: {
        [LogLevel.VERBOSE]: 'VERBOSE',
        [LogLevel.TRACE]: 'TRACE',
        [LogLevel.DEBUG]: 'DEBUG',
        [LogLevel.INFO]: 'INFO',
        [LogLevel.WARN]: 'WARN',
        [LogLevel.ERROR]: 'ERROR',
        [LogLevel.FATAL]: 'FATAL',
    },
    paramsSeperator: ' :: ',
    maxParamStringLength: 250,
    levelNameFixedLength: 0,
    propertyFormatters: {
        timestamp: function (value) {
            return new Date(value).toJSON();
        },
        level: function (value, serializer) {
            const levelName = serializer.config.levelNameMap[value] || `L-${value}`;
            return levelName.padEnd(serializer.config.levelNameFixedLength, ' ');
        },
        params: function (value, serializer) {
            return serializer.serializeParamList(value);
        },
    },
    includeTimestamp: true,
    includeLevel: true,
    includeTag: true,
    includeParams: true,
};
function deepMergeConfig(a, b) {
    const levelNameMap = Object.assign(Object.assign({}, a.levelNameMap), (b.levelNameMap || {}));
    const propertyFormatters = Object.assign(Object.assign({}, a.propertyFormatters), (b.propertyFormatters || {}));
    return Object.assign(Object.assign(Object.assign({}, a), b), { levelNameMap, propertyFormatters });
}
function resolveFormatStringFromConfig(config) {
    if (typeof config.format === 'string' && config.format.length > 0) {
        return config.format;
    }
    let result = '{message}';
    if (config.includeTag) {
        result = `[{tag}] ${result}`;
    }
    if (config.includeLevel) {
        result = `[{level}] ${result}`;
    }
    if (config.includeTimestamp) {
        result = `{timestamp} ${result}`;
    }
    if (config.includeParams) {
        result += '{params}';
    }
    return result;
}
/**
 * Configurable transformer to convert log events into string output.
 */
export class LogEventSerializer {
    constructor(config = {}) {
        this.config = deepMergeConfig(defaultOptions, config);
        this.format = resolveFormatStringFromConfig(this.config);
    }
    /**
     * Obtains a serializer function from the given config
     * @param config - the options to parse a serializer delegate from
     * @returns a function that will convert
     */
    static parseDelegateFrom(config) {
        if (typeof config.serializeEvent === 'function')
            return config.serializeEvent;
        const serializer = config.serializer || new LogEventSerializer(config.serializerConfig);
        return (ev) => serializer.serialize(ev);
    }
    extend(config = {}) {
        return new LogEventSerializer(deepMergeConfig(this.config, config));
    }
    serialize(ev) {
        if (!ev) {
            return '';
        }
        return this.format.replace(/\{(\w+)\}/g, (match, key) => {
            const formatter = this.config.propertyFormatters[key];
            const value = ev[key];
            if (typeof formatter === 'function')
                return formatter(value, this);
            if (key in ev)
                return String(value);
            return match;
        });
    }
    serializeParamList(params) {
        if (!Array.isArray(params) || params.length <= 0) {
            return '';
        }
        let result = '';
        for (const p of params) {
            result += this.config.paramsSeperator + this.serializeParam(p);
        }
        return result;
    }
    serializeParam(param) {
        let s;
        try {
            s = JSON.stringify(param);
        }
        catch (_a) {
            s = param + '';
        }
        const targetLength = this.config.maxParamStringLength;
        const ext = '...';
        if (s.length - ext.length > targetLength) {
            return s.substring(0, targetLength - ext.length) + ext;
        }
        return s;
    }
}