@tsed/logger/lib/esm/node/layouts/LayoutReplacer.js

A multi channel logger written in TypeScript.

import Os from "node:os";
import Util from "node:util";
// @ts-ignore
import * as dateFormat from "date-format";
import { LOG_COLORS } from "../../common/layouts/constants/logColors.js";
import { colorizeEnd, colorizeStart } from "../../common/layouts/utils/colorizeUtils.js";
export class LayoutReplacer {
    static { this.EOL = Os.EOL || "\n"; }
    static { this.HOSTNAME = Os.hostname().toString(); }
    static { this.formatter = Util.format; }
    constructor(tokens, timezoneOffset) {
        this.tokens = tokens;
        this.timezoneOffset = timezoneOffset;
        /**
         *
         * @param loggingEvent
         * @param specifier
         * @returns {any}
         */
        this.categoryName = (loggingEvent, specifier) => {
            let loggerName = loggingEvent.categoryName;
            if (specifier) {
                const precision = parseInt(specifier, 10);
                const loggerNameBits = loggerName.split(".");
                if (precision < loggerNameBits.length) {
                    loggerName = loggerNameBits.slice(loggerNameBits.length - precision).join(".");
                }
            }
            return loggerName;
        };
        /**
         *
         * @param loggingEvent
         * @param specifier
         * @returns {any}
         */
        this.formatAsDate = (loggingEvent, specifier) => {
            let format = dateFormat.ISO8601_FORMAT;
            if (specifier) {
                format = specifier;
                // Pick up special cases
                if (format === "ISO8601") {
                    format = dateFormat.ISO8601_FORMAT;
                }
                else if (format === "ISO8601_WITH_TZ_OFFSET") {
                    format = dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT;
                }
                else if (format === "ABSOLUTE") {
                    format = dateFormat.ABSOLUTETIME_FORMAT;
                }
                else if (format === "DATE") {
                    format = dateFormat.DATETIME_FORMAT;
                }
            }
            // Format the date
            return dateFormat.asString(format, loggingEvent.startTime, this.timezoneOffset);
        };
        /**
         *
         * @returns {string}
         */
        this.hostname = () => {
            return LayoutReplacer.HOSTNAME || "";
        };
        /**
         *
         * @param loggingEvent
         * @returns {any}
         */
        this.formatMessage = (loggingEvent) => {
            return LayoutReplacer.formatter(...loggingEvent.data);
        };
        this.formatJson = (loggingEvent) => {
            return JSON.stringify(loggingEvent.data);
        };
        /**
         *
         * @returns {string|string}
         */
        this.endOfLine = () => {
            return LayoutReplacer.EOL;
        };
        /**
         *
         * @param loggingEvent
         * @returns {string}
         */
        this.logLevel = (loggingEvent) => {
            return loggingEvent.level.toString();
        };
        /**
         *
         * @param loggingEvent
         * @returns {any}
         */
        this.startTime = (loggingEvent) => {
            return dateFormat.asString("hh:mm:ss", loggingEvent.startTime, this.timezoneOffset);
        };
        /**
         *
         * @param loggingEvent
         * @returns {string}
         */
        this.startColour = (loggingEvent) => {
            const index = loggingEvent.level.toString();
            return colorizeStart(LOG_COLORS[index]);
        };
        /**
         *
         * @param loggingEvent
         * @returns {string}
         */
        this.endColour = (loggingEvent) => {
            const index = loggingEvent.level.toString();
            return colorizeEnd(LOG_COLORS[index]);
        };
        /**
         *
         * @returns {string}
         */
        this.percent = () => {
            return "%";
        };
        /**
         *
         * @param loggingEvent
         * @returns {string}
         */
        this.pid = (loggingEvent) => {
            return loggingEvent && loggingEvent.pid ? loggingEvent.pid.toString() : process.pid.toString();
        };
        /**
         *
         * @param loggingEvent
         * @param specifier
         * @returns {any}
         */
        this.clusterInfo = (loggingEvent, specifier) => {
            if (loggingEvent.cluster && specifier) {
                return specifier
                    .replace("%m", loggingEvent.cluster.master)
                    .replace("%w", loggingEvent.cluster.worker)
                    .replace("%i", loggingEvent.cluster.workerId);
            }
            else if (loggingEvent.cluster) {
                return `${loggingEvent.cluster.worker}@${loggingEvent.cluster.master}`;
            }
            return this.pid();
        };
        /**
         *
         * @param loggingEvent
         * @param specifier
         * @returns {any}
         */
        this.userDefined = (loggingEvent, specifier) => {
            if (typeof this.tokens[specifier] !== "undefined") {
                return typeof this.tokens[specifier] === "function" ? this.tokens[specifier](loggingEvent) : this.tokens[specifier];
            }
            return null;
        };
    }
    build() {
        return {
            c: this.categoryName,
            d: this.formatAsDate,
            h: this.hostname,
            m: this.formatMessage,
            j: this.formatJson,
            n: this.endOfLine,
            p: this.logLevel,
            r: this.startTime,
            "[": this.startColour,
            "]": this.endColour,
            y: this.clusterInfo,
            z: this.pid,
            "%": this.percent,
            x: this.userDefined
        };
    }
}
//# sourceMappingURL=LayoutReplacer.js.map