@jaypie/logger 1.1.0

package/dist/cjs/JaypieLogger.d.ts

@@ -0,0 +1,32 @@
+import Logger from "./Logger";
+interface JaypieLoggerOptions {
+    level?: string;
+    tags?: Record<string, string>;
+}
+declare class JaypieLogger {
+    debug: Logger["debug"];
+    error: Logger["error"];
+    fatal: Logger["fatal"];
+    info: Logger["info"];
+    level: string;
+    trace: Logger["trace"];
+    var: Logger["var"];
+    warn: Logger["warn"];
+    private _logger;
+    private _loggers;
+    private _params;
+    private _tags;
+    private _withLoggers;
+    constructor({ level, tags, }?: JaypieLoggerOptions);
+    init(): void;
+    lib({ level, lib, tags, }?: {
+        level?: string;
+        lib?: string;
+        tags?: Record<string, string>;
+    }): JaypieLogger;
+    tag(tags: Record<string, unknown>): void;
+    untag(...args: any[]): void;
+    with(...args: any[]): JaypieLogger;
+}
+export declare function createLogger(tags?: Record<string, string>): JaypieLogger;
+export default JaypieLogger;

package/dist/cjs/Logger.d.ts

@@ -0,0 +1,30 @@
+type LogLevel = string;
+type LogFormat = "json" | "text";
+type Tags = Record<string, string>;
+interface LoggerOptions {
+    format?: LogFormat;
+    level?: LogLevel;
+    tags?: Tags;
+    varLevel?: LogLevel;
+}
+type LogMethod = {
+    (...messages: unknown[]): void;
+    var: (messageObject: unknown, messageValue?: unknown) => void;
+};
+declare class Logger {
+    debug: LogMethod;
+    error: LogMethod;
+    fatal: LogMethod;
+    info: LogMethod;
+    options: LoggerOptions;
+    tags: Tags;
+    trace: LogMethod;
+    var: (messageObject: unknown, messageValue?: unknown) => void;
+    warn: LogMethod;
+    constructor({ format, level, tags, varLevel, }?: LoggerOptions);
+    private createLogMethod;
+    tag(key: unknown, value?: unknown): void;
+    untag(key: unknown): void;
+    with(key: unknown, value?: unknown): Logger;
+}
+export default Logger;

package/dist/cjs/__tests__/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/constants.d.ts

@@ -0,0 +1,29 @@
+export declare const DEFAULT: {
+    LEVEL: string;
+    VAR_LEVEL: string;
+};
+export declare const ERROR_PREFIX = "[logger]";
+export declare const ERROR: {
+    VAR: {
+        EMPTY_OBJECT: string;
+        MULTIPLE_KEYS: string;
+        NULL_OBJECT: string;
+        UNDEFINED_MESSAGE: string;
+    };
+};
+export declare const FORMAT: {
+    readonly JSON: "json";
+    readonly TEXT: "text";
+};
+export declare const LEVEL: {
+    readonly ALL: "all";
+    readonly DEBUG: "debug";
+    readonly ERROR: "error";
+    readonly FATAL: "fatal";
+    readonly INFO: "info";
+    readonly SILENT: "silent";
+    readonly TRACE: "trace";
+    readonly WARN: "warn";
+};
+export declare const LEVEL_VALUES: Record<string, number>;
+export declare const PSEUDO_LEVELS: string[];

package/dist/cjs/forceVar.d.ts

@@ -0,0 +1 @@
+export declare function forceVar(key: unknown, value?: unknown): Record<string, unknown>;

package/dist/cjs/index.cjs

@@ -0,0 +1,606 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const DEFAULT = {
+    LEVEL: "debug",
+    VAR_LEVEL: "debug",
+};
+const ERROR_PREFIX = "[logger]";
+const ERROR = {
+    VAR: {
+        EMPTY_OBJECT: `${ERROR_PREFIX} Logger.var() called with empty object`,
+        MULTIPLE_KEYS: `${ERROR_PREFIX} Logger.var() called with multiple keys`,
+        NULL_OBJECT: `${ERROR_PREFIX} Logger.var() called with null`,
+        UNDEFINED_MESSAGE: `${ERROR_PREFIX} Logger.var() called with \`undefined\` message`,
+    },
+};
+const FORMAT = {
+    JSON: "json",
+    TEXT: "text",
+};
+const LEVEL = {
+    ALL: "all",
+    DEBUG: "debug",
+    ERROR: "error",
+    FATAL: "fatal",
+    INFO: "info",
+    SILENT: "silent",
+    TRACE: "trace",
+    WARN: "warn",
+};
+const LEVEL_VALUES = {
+    all: 100,
+    debug: 70,
+    error: 10,
+    fatal: 1,
+    info: 50,
+    none: 0,
+    silent: 0,
+    trace: 90,
+    warn: 30,
+};
+
+function forceString(value, defaultValue = "") {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return String(defaultValue);
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+function formatAsJsonString(subject) {
+    const SPACES = 0;
+    const UNUSED_PARAM = null;
+    switch (typeof subject) {
+        case "string":
+            if (subject === "")
+                return `""`;
+            try {
+                return JSON.stringify(JSON.parse(subject), UNUSED_PARAM, SPACES);
+            }
+            catch {
+                return subject;
+            }
+        case "object":
+            try {
+                if (subject &&
+                    subject instanceof Object &&
+                    !Array.isArray(subject) &&
+                    subject.constructor &&
+                    subject.constructor !== Object &&
+                    "toString" in subject &&
+                    typeof subject.toString === "function") {
+                    return subject.toString();
+                }
+                return JSON.stringify(subject, UNUSED_PARAM, SPACES);
+            }
+            catch (error) {
+                if (error instanceof TypeError) {
+                    const truncatedSubject = Object.keys(subject).reduce((newSubject, key) => {
+                        const nextSubject = { ...newSubject };
+                        nextSubject[key] = String(subject[key]);
+                        return nextSubject;
+                    }, {});
+                    return formatAsJsonString(truncatedSubject);
+                }
+                throw error;
+            }
+        default:
+            return String(subject);
+    }
+}
+function stringify(...params) {
+    if (params.length === 0)
+        return "";
+    if (params.length === 1) {
+        return formatAsJsonString(params[0]);
+    }
+    const noObjects = params.reduce((previous, current) => {
+        if (typeof current === "object" && current !== null) {
+            return false;
+        }
+        return previous;
+    }, true);
+    if (noObjects) {
+        const formatted = params.map(formatAsJsonString);
+        return formatted.join(" ");
+    }
+    return formatAsJsonString(params);
+}
+function out(line, { level = "debug" } = {}) {
+    let lineStr;
+    if (typeof line !== "string") {
+        lineStr = stringify(line);
+    }
+    else {
+        lineStr = line;
+    }
+    let outputFunction;
+    switch (level) {
+        case LEVEL.INFO:
+            outputFunction = console.info;
+            break;
+        case LEVEL.WARN:
+            outputFunction = console.warn;
+            break;
+        case LEVEL.ERROR:
+        case LEVEL.FATAL:
+            outputFunction = console.error;
+            break;
+        case LEVEL.TRACE:
+        case LEVEL.DEBUG:
+            outputFunction = console.debug;
+            break;
+        default:
+            outputFunction = console.log;
+            break;
+    }
+    try {
+        outputFunction(lineStr);
+    }
+    catch (error) {
+        console.warn(error);
+        console.log(lineStr);
+    }
+}
+function parse(message) {
+    if (typeof message !== "string") {
+        return message;
+    }
+    try {
+        return JSON.parse(message);
+    }
+    catch {
+        return message;
+    }
+}
+function parsesTo(message) {
+    if (typeof message !== "string") {
+        return {
+            parses: false,
+            message,
+        };
+    }
+    try {
+        return {
+            parses: true,
+            message: JSON.parse(message),
+        };
+    }
+    catch {
+        return {
+            parses: false,
+            message,
+        };
+    }
+}
+
+class Logger {
+    constructor({ format = process.env.LOG_FORMAT || DEFAULT.LEVEL, level = process.env.LOG_LEVEL || DEFAULT.LEVEL, tags = {}, varLevel = process.env.LOG_VAR_LEVEL || DEFAULT.VAR_LEVEL, } = {}) {
+        this.options = {
+            format,
+            level,
+            varLevel,
+        };
+        this.tags = {};
+        Object.keys(tags).forEach((key) => {
+            this.tags[key] = forceString(tags[key]);
+        });
+        this.debug = this.createLogMethod(LEVEL.DEBUG, format, level);
+        this.error = this.createLogMethod(LEVEL.ERROR, format, level);
+        this.fatal = this.createLogMethod(LEVEL.FATAL, format, level);
+        this.info = this.createLogMethod(LEVEL.INFO, format, level);
+        this.trace = this.createLogMethod(LEVEL.TRACE, format, level);
+        this.warn = this.createLogMethod(LEVEL.WARN, format, level);
+        const varLevelMethod = this[varLevel];
+        this.var = varLevelMethod?.var || this.debug.var;
+    }
+    createLogMethod(logLevel, format, checkLevel) {
+        const logFn = (...messages) => {
+            if (LEVEL_VALUES[logLevel] <= LEVEL_VALUES[checkLevel]) {
+                if (format === FORMAT.JSON) {
+                    const message = stringify(...messages);
+                    const parses = parsesTo(message);
+                    const json = {
+                        log: logLevel,
+                        message,
+                        ...this.tags,
+                    };
+                    if (parses.parses) {
+                        json.data = parses.message;
+                    }
+                    out(json, { level: logLevel });
+                }
+                else {
+                    const message = stringify(...messages);
+                    out(message, { level: logLevel });
+                }
+            }
+        };
+        logFn.var = (messageObject, messageValue) => {
+            if (messageObject === undefined) {
+                this.warn(ERROR.VAR.UNDEFINED_MESSAGE);
+            }
+            let msgObj;
+            if (typeof messageObject !== "object" || messageObject === null) {
+                if (typeof messageObject !== "object") {
+                    if (messageValue === undefined)
+                        messageValue = "undefined";
+                    msgObj = { [String(messageObject)]: messageValue };
+                }
+                else {
+                    this.warn(ERROR.VAR.NULL_OBJECT);
+                    return logFn(messageObject);
+                }
+            }
+            else {
+                msgObj = messageObject;
+            }
+            const keys = Object.keys(msgObj);
+            if (keys.length === 0) {
+                this.warn(ERROR.VAR.EMPTY_OBJECT);
+                return logFn(msgObj);
+            }
+            if (keys.length > 1) {
+                this.warn(ERROR.VAR.MULTIPLE_KEYS);
+                return logFn(msgObj);
+            }
+            if (format === FORMAT.JSON) {
+                const messageKey = keys[0];
+                const messageVal = msgObj[messageKey];
+                const json = {
+                    data: parse(messageVal),
+                    dataType: typeof messageVal,
+                    log: logLevel,
+                    message: stringify(messageVal),
+                    var: messageKey,
+                    ...this.tags,
+                };
+                if (LEVEL_VALUES[logLevel] <= LEVEL_VALUES[checkLevel]) {
+                    out(json, { level: logLevel });
+                }
+            }
+            else {
+                return logFn(msgObj);
+            }
+        };
+        return logFn;
+    }
+    tag(key, value) {
+        if (value) {
+            this.tags[forceString(key)] = forceString(value);
+            return;
+        }
+        if (Array.isArray(key)) {
+            key.forEach((k) => {
+                this.tags[forceString(k)] = "";
+            });
+            return;
+        }
+        if (key === null) {
+            this.tags.null = "";
+            return;
+        }
+        if (typeof key === "object") {
+            Object.keys(key).forEach((k) => {
+                this.tags[forceString(k)] = forceString(key[k]);
+            });
+        }
+        else {
+            this.tags[forceString(key)] = "";
+        }
+    }
+    untag(key) {
+        if (Array.isArray(key)) {
+            key.forEach((k) => {
+                delete this.tags[forceString(k)];
+            });
+            return;
+        }
+        if (key === null) {
+            delete this.tags.null;
+            return;
+        }
+        if (typeof key === "object") {
+            Object.keys(key).forEach((k) => {
+                delete this.tags[forceString(k)];
+            });
+        }
+        else {
+            delete this.tags[forceString(key)];
+        }
+    }
+    with(key, value) {
+        const logger = new Logger(this.options);
+        logger.tag(this.tags);
+        logger.tag(key, value);
+        return logger;
+    }
+}
+
+function logTags(withTags) {
+    const { PROJECT_COMMIT, PROJECT_ENV, PROJECT_KEY, PROJECT_SERVICE, PROJECT_SPONSOR, PROJECT_VERSION, } = process.env;
+    const tags = {};
+    if (PROJECT_COMMIT) {
+        tags.commit = PROJECT_COMMIT;
+    }
+    if (PROJECT_ENV) {
+        tags.env = PROJECT_ENV;
+    }
+    if (PROJECT_KEY) {
+        tags.project = PROJECT_KEY;
+    }
+    if (PROJECT_SERVICE) {
+        tags.service = PROJECT_SERVICE;
+    }
+    if (PROJECT_SPONSOR) {
+        tags.sponsor = PROJECT_SPONSOR;
+    }
+    if (process.env.npm_package_version || PROJECT_VERSION) {
+        tags.version = (process.env.npm_package_version ||
+            PROJECT_VERSION);
+    }
+    return {
+        ...tags,
+        ...withTags,
+    };
+}
+
+function forceVar(key, value) {
+    if (typeof key === "undefined") {
+        return {};
+    }
+    if (typeof key === "object" && key !== null) {
+        if (Object.keys(key).length === 1) {
+            return key;
+        }
+        else {
+            return { value: key };
+        }
+    }
+    const keyStr = forceString(key);
+    if (typeof value === "undefined") {
+        return { [keyStr]: "" };
+    }
+    else {
+        return { [keyStr]: value };
+    }
+}
+
+function isAxiosResponse(response) {
+    if (typeof response !== "object" || response === null) {
+        return false;
+    }
+    const r = response;
+    return !!(r &&
+        r.config &&
+        r.data &&
+        r.headers &&
+        r.request &&
+        r.status &&
+        r.statusText);
+}
+function filterAxiosResponse(response) {
+    if (!isAxiosResponse(response)) {
+        return response;
+    }
+    const r = response;
+    const newResponse = {
+        data: r.data,
+        headers: r.headers,
+        status: r.status,
+        statusText: r.statusText,
+    };
+    if (r.isAxiosError) {
+        newResponse.isAxiosError = r.isAxiosError;
+    }
+    return newResponse;
+}
+const axiosResponseVarPipeline = {
+    filter: filterAxiosResponse,
+    key: "response",
+};
+function isError(item) {
+    if (typeof item !== "object" || item === null) {
+        return false;
+    }
+    if (item instanceof Error) {
+        return true;
+    }
+    const i = item;
+    if (i.isProjectError) {
+        return true;
+    }
+    return false;
+}
+function filterErrorVar(item) {
+    if (!isError(item)) {
+        return item;
+    }
+    const e = item;
+    const newItem = {
+        message: e.message,
+        name: e.name,
+    };
+    if (e.cause) {
+        newItem.cause = e.cause;
+    }
+    if (e.stack) {
+        newItem.stack = e.stack;
+    }
+    if (e.isProjectError) {
+        newItem.isProjectError = e.isProjectError;
+        newItem.title = e.title;
+        newItem.detail = e.detail;
+        newItem.status = e.status;
+    }
+    return newItem;
+}
+const errorVarPipeline = {
+    filter: filterErrorVar,
+    key: "error",
+};
+const pipelines = [axiosResponseVarPipeline, errorVarPipeline];
+
+function keyValueToArray(keyValue) {
+    const key = Object.keys(keyValue)[0];
+    return [key, keyValue[key]];
+}
+function logVar(key, value) {
+    let [k, v] = keyValueToArray(forceVar(key, value));
+    for (const pipeline of pipelines) {
+        if (k === pipeline.key) {
+            v = pipeline.filter(v);
+        }
+    }
+    return { [k]: v };
+}
+
+function envBoolean(key, { defaultValue }) {
+    const value = process.env[key];
+    if (value === undefined)
+        return defaultValue;
+    const lower = value.toLowerCase();
+    return !(lower === "" ||
+        lower === "0" ||
+        lower === "f" ||
+        lower === "false" ||
+        lower === "n" ||
+        lower === "no");
+}
+class JaypieLogger {
+    constructor({ level = process.env.LOG_LEVEL, tags = {}, } = {}) {
+        this._params = { level, tags };
+        this._loggers = [];
+        this._tags = {};
+        this._withLoggers = {};
+        this.level = level || DEFAULT.LEVEL;
+        this._tags = { ...logTags(), ...tags };
+        this._logger = new Logger({
+            format: FORMAT.JSON,
+            level: this.level,
+            tags: this._tags,
+        });
+        this._loggers = [this._logger];
+        this.debug = ((...args) => this._logger.debug(...args));
+        this.debug.var = (...args) => this._logger.debug.var(...args);
+        this.error = ((...args) => this._logger.error(...args));
+        this.error.var = (...args) => this._logger.error.var(...args);
+        this.fatal = ((...args) => this._logger.fatal(...args));
+        this.fatal.var = (...args) => this._logger.fatal.var(...args);
+        this.info = ((...args) => this._logger.info(...args));
+        this.info.var = (...args) => this._logger.info.var(...args);
+        this.trace = ((...args) => this._logger.trace(...args));
+        this.trace.var = (...args) => this._logger.trace.var(...args);
+        this.warn = ((...args) => this._logger.warn(...args));
+        this.warn.var = (...args) => this._logger.warn.var(...args);
+        this.var = (...args) => this._logger.var(logVar(...args));
+    }
+    init() {
+        for (const logger of this._loggers) {
+            if ("init" in logger && typeof logger.init === "function") {
+                logger.init();
+            }
+        }
+        const level = this._params.level;
+        const tags = this._params.tags;
+        this.level = level || DEFAULT.LEVEL;
+        this._tags = { ...logTags(), ...tags };
+        this._logger = new Logger({
+            format: FORMAT.JSON,
+            level: this.level,
+            tags: this._tags,
+        });
+        this._loggers = [this._logger];
+        this._withLoggers = {};
+        const levels = [
+            "debug",
+            "error",
+            "fatal",
+            "info",
+            "trace",
+            "warn",
+        ];
+        levels.forEach((lvl) => {
+            this[lvl] = ((...args) => {
+                this._logger[lvl](...args);
+            });
+            this[lvl].var = (...args) => {
+                this._logger[lvl].var(...args);
+            };
+        });
+    }
+    lib({ level, lib, tags = {}, } = {}) {
+        const newTags = Object.assign({}, this._tags, tags);
+        if (lib) {
+            newTags.lib = lib;
+        }
+        const logger = new JaypieLogger({
+            level: (() => {
+                if (level) {
+                    return level;
+                }
+                if (process.env.MODULE_LOG_LEVEL) {
+                    return process.env.MODULE_LOG_LEVEL;
+                }
+                if (envBoolean("MODULE_LOGGER", { defaultValue: false })) {
+                    return process.env.LOG_LEVEL;
+                }
+                return LEVEL.SILENT;
+            })(),
+            tags: newTags,
+        });
+        this._loggers.push(logger._logger);
+        return logger;
+    }
+    tag(tags) {
+        for (const logger of this._loggers) {
+            logger.tag(tags);
+        }
+        Object.assign(this._tags, tags);
+    }
+    untag(...args) {
+        for (const logger of this._loggers) {
+            logger.untag(...args);
+        }
+        for (const key of Object.keys(args)) {
+            delete this._tags[key];
+        }
+    }
+    with(...args) {
+        if (!args || typeof args !== "object") {
+            throw new Error("ConfigurationError: with() requires an object argument");
+        }
+        const loggerKey = JSON.stringify(args);
+        if (Object.keys(this._withLoggers).includes(loggerKey)) {
+            return this._withLoggers[loggerKey];
+        }
+        const logger = new JaypieLogger({
+            level: this.level,
+            tags: { ...this._tags },
+        });
+        logger._logger = this._logger.with(...args);
+        logger._loggers = [logger._logger];
+        this._withLoggers[loggerKey] = logger;
+        this._loggers.push(logger._logger);
+        return logger;
+    }
+}
+function createLogger(tags = {}) {
+    const jaypieLogger = new JaypieLogger({
+        tags,
+    });
+    return jaypieLogger;
+}
+
+const log = createLogger();
+
+exports.FORMAT = FORMAT;
+exports.LEVEL = LEVEL;
+exports.Logger = Logger;
+exports.createLogger = createLogger;
+exports.default = log;
+exports.log = log;
+//# sourceMappingURL=index.cjs.map