@lakutata/logger 0.0.0-stage → 3.0.0-beta.1

package/dist/esm/lib/Pretty.js

@@ -0,0 +1,262 @@
+const EOL = '\n';
+const IDENT = '    ';
+const LEVEL_LABELS = { default: 'USERLVL', 60: 'FATAL', 50: 'ERROR', 40: 'WARN', 30: 'INFO', 20: 'DEBUG', 10: 'TRACE' };
+const LEVEL_NUMBERS = { fatal: 60, error: 50, warn: 40, info: 30, debug: 20, trace: 10 };
+//The keys of the logger, not printed as properties
+const LOGGER_KEYS = ['pid', 'hostname', 'name', 'level', 'time', 'timestamp', 'caller'];
+const ERROR_KEYS = new Set(['err', 'error']);
+/**
+ * The JSON of a property value, indented by 2 spaces
+ * @param value
+ */
+function propertyJSON(value) {
+    switch (typeof value) {
+        case 'number':
+        case 'boolean':
+            return String(value);
+        case 'string':
+            return JSON.stringify(value);
+        default:
+            return JSON.stringify(value, null, 2);
+    }
+}
+const hasOwn = Object.hasOwn;
+//The prototype pollution suspects of a JSON text
+const SUSPECT_PROTO = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+const SUSPECT_CONSTRUCTOR = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+/**
+ * Remove the "__proto__" properties of a parsed log, false if it has a constructor with a prototype (not printed as a log)
+ * @param log
+ */
+function sanitize(log) {
+    let next = [log];
+    try {
+        while (next.length) {
+            const nodes = next;
+            next = [];
+            for (const node of nodes) {
+                if (hasOwn(node, '__proto__'))
+                    delete node.__proto__;
+                if (hasOwn(node, 'constructor') && Object.prototype.hasOwnProperty.call(node.constructor, 'prototype'))
+                    return false;
+                for (const key in node) {
+                    const value = node[key];
+                    if (value && typeof value === 'object')
+                        next.push(value);
+                }
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+/**
+ * Indent the lines after the first one
+ * @param input
+ * @param ident
+ */
+function joinLines(input, ident = IDENT) {
+    const lines = input.split(/\r?\n/);
+    for (let index = 1; index < lines.length; index++)
+        lines[index] = ident + lines[index];
+    return lines.join(EOL);
+}
+/**
+ * Whether a value is a plain object
+ * @param value
+ */
+function isObjectValue(value) {
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+/**
+ * Pad a number with zeros
+ * @param value
+ * @param length
+ */
+function pad(value, length = 2) {
+    return String(value).padStart(length, '0');
+}
+/**
+ * The time of a log, HH:MM:ss.SSS in the local time zone
+ * @param log
+ */
+function prettyTime(log) {
+    let time = null;
+    if ('time' in log) {
+        time = log.time;
+    }
+    else if ('timestamp' in log) {
+        time = log.timestamp;
+    }
+    if (time === null)
+        return undefined;
+    let date = new Date(time);
+    if (isNaN(date.getTime()))
+        date = new Date(+time);
+    if (isNaN(date.getTime()))
+        return `[${time}]`;
+    return `[${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}]`;
+}
+/**
+ * The label of the level of a log
+ * @param log
+ * @param palette
+ */
+function prettyLevel(log, palette) {
+    if (!hasOwn(log, 'level'))
+        return undefined;
+    const level = log.level;
+    if (level === undefined)
+        return undefined;
+    let levelNumber = 'default';
+    if (Number.isInteger(+level)) {
+        levelNumber = hasOwn(LEVEL_LABELS, level) ? level : levelNumber;
+    }
+    else {
+        const name = String(level).toLowerCase();
+        levelNumber = hasOwn(LEVEL_NUMBERS, name) ? LEVEL_NUMBERS[name] : levelNumber;
+    }
+    const label = LEVEL_LABELS[levelNumber];
+    return hasOwn(palette.level, levelNumber) ? palette.level[levelNumber](label) : palette.level.default(label);
+}
+/**
+ * The metadata of a log: (name/pid on hostname) <caller>
+ * @param log
+ */
+function prettyMetadata(log) {
+    let line = '';
+    if (log.name || log.pid || log.hostname) {
+        line += '(';
+        if (log.name)
+            line += log.name;
+        if (log.pid)
+            line += log.name ? `/${log.pid}` : log.pid;
+        if (log.hostname)
+            line += `${line === '(' ? 'on' : ' on'} ${log.hostname}`;
+        line += ')';
+    }
+    if (log.caller)
+        line += `${line === '' ? '' : ' '}<${log.caller}>`;
+    return line === '' ? undefined : line;
+}
+/**
+ * An error property, its stack is written on its own lines
+ * @param key
+ * @param lines
+ */
+function prettyError(key, lines) {
+    let result = '';
+    const splitLines = `${IDENT}${key}: ${joinLines(lines)}${EOL}`.split(EOL);
+    for (let index = 0; index < splitLines.length; index++) {
+        if (index)
+            result += EOL;
+        const line = splitLines[index];
+        const matches = /^\s*"stack"/.test(line) ? /^(\s*"stack":)\s*(".*"),?$/.exec(line) : null;
+        if (matches) {
+            const indentation = ' '.repeat(/^\s*/.exec(line)[0].length + 4);
+            result += matches[1] + EOL + indentation + JSON.parse(matches[2]).replace(/\n/g, EOL + indentation);
+        }
+        else {
+            result += line;
+        }
+    }
+    return result;
+}
+/**
+ * The properties of a log, one per line
+ * @param log
+ * @param palette
+ * @param skipKeys
+ * @param excludeLoggerKeys
+ * @param ident
+ */
+function prettyObject(log, palette, skipKeys, excludeLoggerKeys = true, ident = IDENT) {
+    let result = '';
+    let errors;
+    for (const key in log) {
+        if (!hasOwn(log, key) || skipKeys.includes(key) || (excludeLoggerKeys && LOGGER_KEYS.includes(key)))
+            continue;
+        const value = log[key];
+        if (ERROR_KEYS.has(key)) {
+            (errors ??= []).push([key, value]);
+            continue;
+        }
+        let lines = propertyJSON(value);
+        if (lines === undefined)
+            continue;
+        if (lines.includes('\\\\'))
+            lines = lines.replace(/\\\\/gi, '\\');
+        const joinedLines = lines.includes('\n') ? joinLines(lines, ident) : lines;
+        result += `${ident}${palette.property(key)}:${joinedLines.startsWith(EOL) ? '' : ' '}${joinedLines}${EOL}`;
+    }
+    if (!errors)
+        return result;
+    for (const [key, value] of errors) {
+        const lines = JSON.stringify(value, null, 2);
+        if (lines !== undefined)
+            result += prettyError(key, lines);
+    }
+    return result;
+}
+/**
+ * A log which is an error: its stack
+ * @param log
+ * @param palette
+ */
+function prettyErrorLog(log, palette) {
+    let result = `${IDENT}${joinLines(log.stack)}${EOL}`;
+    //The error properties to print: none
+    if ('' in log) {
+        result += isObjectValue(log['']) ? `${IDENT}: {${EOL}${prettyObject(log[''], palette, [], false, IDENT + IDENT)}${IDENT}}${EOL}` : `${IDENT}: ${log['']}${EOL}`;
+    }
+    return result;
+}
+/**
+ * Format a JSON log line for humans:
+ * [time] LEVEL (name/pid): message, then the properties on their own lines
+ * @param line the JSON log line, without its line terminator
+ * @param palette
+ * @param parsed the parsed line, if it is known (the log is changed)
+ */
+export function pretty(line, palette, parsed) {
+    let log;
+    if (parsed) {
+        log = parsed;
+    }
+    else {
+        try {
+            log = JSON.parse(line);
+        }
+        catch {
+            return line + EOL;
+        }
+        if (!isObjectValue(log))
+            return line + EOL;
+    }
+    if ((SUSPECT_PROTO.test(line) || SUSPECT_CONSTRUCTOR.test(line)) && !sanitize(log))
+        return line + EOL;
+    const message = 'msg' in log && (typeof log.msg === 'string' || typeof log.msg === 'number' || typeof log.msg === 'boolean') ? palette.message(log.msg) : undefined;
+    //The host name is not printed
+    if (hasOwn(log, 'hostname'))
+        delete log.hostname;
+    const level = prettyLevel(log, palette);
+    const metadata = prettyMetadata(log);
+    const time = prettyTime(log);
+    let result = time ?? '';
+    if (level)
+        result = result ? `${result} ${level}` : level;
+    if (metadata)
+        result = result ? `${result} ${metadata}:` : metadata;
+    if (!result.endsWith(':') && result !== '')
+        result += ':';
+    if (message !== undefined)
+        result = result ? `${result} ${message}` : message;
+    if (result.length)
+        result += EOL;
+    if (log.type === 'Error' && typeof log.stack === 'string')
+        return result + prettyErrorLog(log, palette);
+    const skipKeys = ['msg', 'level', 'time'].filter((key) => typeof log[key] === 'string' || typeof log[key] === 'number' || typeof log[key] === 'boolean');
+    return result + prettyObject(log, palette, skipKeys);
+}

package/dist/esm/lib/Record.js

@@ -0,0 +1,134 @@
+//Derived from the upstream projects listed in THIRD_PARTY_NOTICES.md (rewritten in TypeScript)
+import { hostname } from 'node:os';
+import { format } from './Format.js';
+import { serializeError, serializeRequest, serializeResponse } from './Serializers.js';
+import { stringify } from './Stringify.js';
+export const LEVELS = { trace: 10, debug: 20, info: 30, warn: 40, error: 50, fatal: 60, silent: Infinity };
+const HOSTNAME = hostname();
+/**
+ * The JSON of a log value, undefined if it is not logged
+ * @param value
+ */
+function valueJSON(value) {
+    switch (typeof value) {
+        case 'undefined':
+        case 'function':
+            return undefined;
+        case 'number':
+            return Number.isFinite(value) ? String(value) : 'null';
+        case 'boolean':
+            return String(value);
+        case 'string':
+            return JSON.stringify(value);
+        default:
+            return stringify(value);
+    }
+}
+/**
+ * The bindings of the log lines of an application: pid, hostname and name
+ * @param name
+ */
+export function logBindings(name) {
+    return { json: `,"pid":${process.pid},"hostname":${JSON.stringify(HOSTNAME)},"name":${JSON.stringify(name)}`, name: name };
+}
+/**
+ * The value of a JSON text, as parsed
+ * @param value
+ * @param json
+ */
+function parsedValue(value, json) {
+    switch (typeof value) {
+        case 'string':
+        case 'boolean':
+            return value;
+        case 'number':
+            return Number.isFinite(value) ? value + 0 : null;
+        default:
+            return JSON.parse(json);
+    }
+}
+/**
+ * Set a property of a parsed log, as JSON.parse does (the first position and the last value of a key)
+ * @param log
+ * @param key
+ * @param value
+ */
+function setParsed(log, key, value) {
+    key === '__proto__' ? Object.defineProperty(log, key, { value: value, enumerable: true, writable: true, configurable: true }) : log[key] = value;
+}
+/**
+ * Build a JSON log line from the arguments of a log method:
+ * an object (or error, HTTP request or response) with an optional message and its format arguments,
+ * or a message with its format arguments
+ * @param level
+ * @param bindings
+ * @param args
+ * @param parse whether to also build the parsed line
+ * @param redacted the lower-case names of the headers of an HTTP request or response written as [Redacted]
+ */
+export function buildRecord(level, bindings, args, parse = false, redacted = new Set()) {
+    let object = null;
+    let message;
+    let [first, ...rest] = args;
+    if (typeof first === 'object') {
+        message = first;
+        if (first !== null) {
+            if (first.method && first.headers && first.socket) {
+                first = { req: serializeRequest(first, redacted) };
+            }
+            else if (typeof first.setHeader === 'function') {
+                first = { res: serializeResponse(first, redacted) };
+            }
+        }
+        let formatArgs;
+        if (message === null && !rest.length) {
+            formatArgs = [null];
+        }
+        else {
+            message = rest.shift();
+            formatArgs = rest;
+        }
+        object = first;
+        message = format(message, formatArgs);
+    }
+    else {
+        message = format(first === undefined ? rest.shift() : first, rest);
+    }
+    if (object === undefined || object === null) {
+        object = {};
+    }
+    else if (object instanceof Error) {
+        if (message === undefined)
+            message = object.message;
+        object = { err: object };
+    }
+    else if (message === undefined && object.msg === undefined && object.err) {
+        message = object.err.message;
+    }
+    const time = Date.now();
+    let line = `{"level":${level},"time":${time}${bindings.json}`;
+    const log = parse ? { level: level, time: time, pid: process.pid, hostname: HOSTNAME, name: bindings.name } : undefined;
+    for (const key in object) {
+        let value = object[key];
+        if (!Object.prototype.hasOwnProperty.call(object, key) || value === undefined)
+            continue;
+        if (key === 'err')
+            value = serializeError(value);
+        const json = valueJSON(value);
+        if (json === undefined)
+            continue;
+        line += `,${JSON.stringify(key)}:${json}`;
+        if (log)
+            setParsed(log, key, parsedValue(value, json));
+    }
+    if (message !== undefined && typeof message !== 'function') {
+        const json = typeof message === 'string' ? JSON.stringify(message) : valueJSON(message);
+        //A message which cannot be serialized (a symbol) is omitted
+        if (json !== undefined) {
+            line += `,"msg":${json}`;
+            if (log)
+                setParsed(log, 'msg', parsedValue(message, json));
+        }
+    }
+    return { line: `${line}}\n`, log: log };
+}

package/dist/esm/lib/Serializers.js

@@ -0,0 +1,143 @@
+//Derived from the upstream projects listed in THIRD_PARTY_NOTICES.md (rewritten in TypeScript)
+const SEEN = Symbol('seen');
+/**
+ * Whether a value looks like an error
+ * @param value
+ */
+export function isErrorLike(value) {
+    return !!value && typeof value.message === 'string';
+}
+/**
+ * The cause of an error
+ * @param error
+ */
+function causeOf(error) {
+    if (!error)
+        return undefined;
+    const cause = typeof error.cause === 'function' ? error.cause() : error.cause;
+    return isErrorLike(cause) ? cause : undefined;
+}
+/**
+ * The stack of an error followed by the stacks of its causes
+ * @param error
+ * @param seen
+ */
+function stackWithCauses(error, seen = new Set()) {
+    if (!isErrorLike(error))
+        return '';
+    const stack = error.stack || '';
+    if (seen.has(error))
+        return `${stack}\ncauses have become circular...`;
+    const cause = causeOf(error);
+    if (!cause)
+        return stack;
+    seen.add(error);
+    return `${stack}\ncaused by: ${stackWithCauses(cause, seen)}`;
+}
+/**
+ * The message of an error followed by the messages of its causes
+ * @param error
+ * @param seen
+ * @param skip
+ */
+function messageWithCauses(error, seen = new Set(), skip = false) {
+    if (!isErrorLike(error))
+        return '';
+    const message = skip ? '' : (error.message || '');
+    if (seen.has(error))
+        return `${message}: ...`;
+    const cause = causeOf(error);
+    if (!cause)
+        return message;
+    seen.add(error);
+    //A cause function (VError) already includes the message of its cause, as an error wrapping a cause of the same
+    //message (an exception keeping the original error)
+    const included = typeof error.cause === 'function' || (!skip && !seen.has(cause) && message === cause.message);
+    return message + (included ? '' : ': ') + messageWithCauses(cause, seen, included);
+}
+/**
+ * Serialize an error: type, message and stack (with the causes), aggregated errors and the other enumerable properties
+ * @param error
+ */
+export function serializeError(error) {
+    if (!isErrorLike(error))
+        return error;
+    error[SEEN] = undefined;
+    const serialized = {};
+    serialized.type = Object.prototype.toString.call(error.constructor) === '[object Function]' ? error.constructor.name : error.name;
+    serialized.message = messageWithCauses(error);
+    serialized.stack = stackWithCauses(error);
+    if (Array.isArray(error.errors))
+        serialized.aggregateErrors = error.errors.map((item) => serializeError(item));
+    for (const key in error) {
+        //"raw" is reserved for the original error (not serialized)
+        if (serialized[key] !== undefined || key === 'raw')
+            continue;
+        const value = error[key];
+        if (isErrorLike(value)) {
+            if (key !== 'cause' && !Object.prototype.hasOwnProperty.call(value, SEEN))
+                serialized[key] = serializeError(value);
+        }
+        else {
+            serialized[key] = value;
+        }
+    }
+    delete error[SEEN];
+    return serialized;
+}
+/**
+ * The headers written as [Redacted] by default: the credentials of the requests and of the responses
+ */
+export const REDACTED_HEADERS = Object.freeze(['authorization', 'cookie', 'set-cookie', 'proxy-authorization']);
+/**
+ * A copy of headers, the values of the redacted ones (lower-case names) replaced by [Redacted]
+ * @param headers
+ * @param redacted
+ */
+function redactHeaders(headers, redacted) {
+    if (!redacted.size || !headers || typeof headers !== 'object')
+        return headers;
+    //A copy: the headers of the request or the response are not changed
+    const copy = { ...headers };
+    for (const name of Object.keys(copy))
+        if (redacted.has(name.toLowerCase()))
+            copy[name] = '[Redacted]';
+    return copy;
+}
+/**
+ * Serialize an HTTP request
+ * @param request
+ * @param redacted the lower-case names of the headers written as [Redacted]
+ */
+export function serializeRequest(request, redacted = new Set()) {
+    const connection = request.info || request.socket;
+    const serialized = {};
+    serialized.id = typeof request.id === 'function' ? request.id() : (request.id || (request.info ? request.info.id : undefined));
+    serialized.method = request.method;
+    if (request.originalUrl) {
+        serialized.url = request.originalUrl;
+    }
+    else {
+        const path = request.path;
+        serialized.url = typeof path === 'string' ? path : (request.url ? request.url.path || request.url : undefined);
+    }
+    if (request.query)
+        serialized.query = request.query;
+    if (request.params)
+        serialized.params = request.params;
+    serialized.headers = redactHeaders(request.headers, redacted);
+    serialized.remoteAddress = connection && connection.remoteAddress;
+    serialized.remotePort = connection && connection.remotePort;
+    return serialized;
+}
+/**
+ * Serialize an HTTP response
+ * @param response
+ * @param redacted the lower-case names of the headers written as [Redacted]
+ */
+export function serializeResponse(response, redacted = new Set()) {
+    return {
+        statusCode: response.headersSent ? response.statusCode : null,
+        headers: redactHeaders(response.getHeaders ? response.getHeaders() : response._headers, redacted)
+    };
+}

package/dist/esm/lib/Stringify.js

@@ -0,0 +1,107 @@
+//Derived from the upstream projects listed in THIRD_PARTY_NOTICES.md (rewritten in TypeScript)
+const MAXIMUM_DEPTH = 5;
+const MAXIMUM_BREADTH = 100;
+const TypedArrayToStringTag = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Int8Array.prototype), Symbol.toStringTag).get;
+/**
+ * The count of the omitted items
+ * @param count
+ */
+function itemCount(count) {
+    return count === 1 ? '1 item' : `${count} items`;
+}
+/**
+ * Serialize a value which JSON cannot (circular references, bigints):
+ * sorted keys, circular references as "[Circular]", limited depth and breadth
+ * @param key
+ * @param value
+ * @param stack
+ */
+function safeStringify(key, value, stack) {
+    switch (typeof value) {
+        case 'string':
+            return JSON.stringify(value);
+        case 'number':
+            return isFinite(value) ? String(value) : 'null';
+        case 'boolean':
+            return value ? 'true' : 'false';
+        case 'bigint':
+            return String(value);
+        case 'object': {
+            if (value === null)
+                return 'null';
+            if (typeof value.toJSON === 'function') {
+                value = value.toJSON(key);
+                if (typeof value !== 'object')
+                    return safeStringify(key, value, stack);
+                if (value === null)
+                    return 'null';
+            }
+            if (stack.includes(value))
+                return '"[Circular]"';
+            let result = '';
+            if (Array.isArray(value)) {
+                if (!value.length)
+                    return '[]';
+                if (MAXIMUM_DEPTH < stack.length + 1)
+                    return '"[Array]"';
+                stack.push(value);
+                const count = Math.min(value.length, MAXIMUM_BREADTH);
+                for (let index = 0; index < count; index++) {
+                    result += `${index ? ',' : ''}${safeStringify(String(index), value[index], stack) ?? 'null'}`;
+                }
+                if (value.length - 1 > MAXIMUM_BREADTH)
+                    result += `,"... ${itemCount(value.length - MAXIMUM_BREADTH - 1)} not stringified"`;
+                stack.pop();
+                return `[${result}]`;
+            }
+            let keys = Object.keys(value);
+            const keyCount = keys.length;
+            if (!keyCount)
+                return '{}';
+            if (MAXIMUM_DEPTH < stack.length + 1)
+                return '"[Object]"';
+            let separator = '';
+            let count = Math.min(keyCount, MAXIMUM_BREADTH);
+            if (value.length !== undefined && TypedArrayToStringTag.call(value) !== undefined && value.length !== 0) {
+                const items = Math.min(value.length, MAXIMUM_BREADTH);
+                for (let index = 0; index < items; index++)
+                    result += `${index ? ',' : ''}"${index}":${value[index]}`;
+                keys = keys.slice(value.length);
+                count -= value.length;
+                separator = ',';
+            }
+            keys.sort();
+            stack.push(value);
+            for (let index = 0; index < count; index++) {
+                const item = safeStringify(keys[index], value[keys[index]], stack);
+                if (item === undefined)
+                    continue;
+                result += `${separator}${JSON.stringify(keys[index])}:${item}`;
+                separator = ',';
+            }
+            if (keyCount > MAXIMUM_BREADTH)
+                result += `${separator}"...":"${itemCount(keyCount - MAXIMUM_BREADTH)} not stringified"`;
+            stack.pop();
+            return `{${result}}`;
+        }
+        default:
+            return undefined;
+    }
+}
+/**
+ * Serialize a value to JSON, the values JSON cannot serialize are serialized safely
+ * @param value
+ */
+export function stringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        try {
+            return safeStringify('', value, []);
+        }
+        catch {
+            return '"[unable to serialize, circular reference is too complex to analyze]"';
+        }
+    }
+}