@rife/logger 0.0.5-beta.9 → 0.0.6-beta.3

package/dist/worker/thread-stream.cjs

@@ -0,0 +1,172 @@
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/real-require@0.2.0/node_modules/real-require/src/index.js": function(module1) {
+        const realImport = new Function('modulePath', 'return import(modulePath)');
+        function realRequire(modulePath) {
+            if ('function' == typeof __non_webpack__require__) return __non_webpack__require__(modulePath);
+            return require(modulePath);
+        }
+        module1.exports = {
+            realImport,
+            realRequire
+        };
+    },
+    "../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/indexes.js": function(module1) {
+        "use strict";
+        const WRITE_INDEX = 4;
+        const READ_INDEX = 8;
+        module1.exports = {
+            WRITE_INDEX,
+            READ_INDEX
+        };
+    },
+    "../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/wait.js": function(module1) {
+        "use strict";
+        const MAX_TIMEOUT = 1000;
+        function wait(state, index, expected, timeout, done) {
+            const max = Date.now() + timeout;
+            let current = Atomics.load(state, index);
+            if (current === expected) return void done(null, 'ok');
+            let prior = current;
+            const check = (backoff)=>{
+                if (Date.now() > max) done(null, 'timed-out');
+                else setTimeout(()=>{
+                    prior = current;
+                    current = Atomics.load(state, index);
+                    if (current === prior) check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : 2 * backoff);
+                    else current === expected ? done(null, 'ok') : done(null, 'not-equal');
+                }, backoff);
+            };
+            check(1);
+        }
+        function waitDiff(state, index, expected, timeout, done) {
+            const max = Date.now() + timeout;
+            let current = Atomics.load(state, index);
+            if (current !== expected) return void done(null, 'ok');
+            const check = (backoff)=>{
+                if (Date.now() > max) done(null, 'timed-out');
+                else setTimeout(()=>{
+                    current = Atomics.load(state, index);
+                    if (current !== expected) done(null, 'ok');
+                    else check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : 2 * backoff);
+                }, backoff);
+            };
+            check(1);
+        }
+        module1.exports = {
+            wait,
+            waitDiff
+        };
+    },
+    worker_threads: function(module1) {
+        "use strict";
+        module1.exports = require("worker_threads");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module1 = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module1, module1.exports, __webpack_require__);
+    return module1.exports;
+}
+var __webpack_exports__ = {};
+(()=>{
+    "use strict";
+    const { realImport, realRequire } = __webpack_require__("../../node_modules/.pnpm/real-require@0.2.0/node_modules/real-require/src/index.js");
+    const { workerData, parentPort } = __webpack_require__("worker_threads");
+    const { WRITE_INDEX, READ_INDEX } = __webpack_require__("../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/indexes.js");
+    const { waitDiff } = __webpack_require__("../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/wait.js");
+    const { dataBuf, filename, stateBuf } = workerData;
+    let destination;
+    const state = new Int32Array(stateBuf);
+    const data = Buffer.from(dataBuf);
+    async function start() {
+        let worker;
+        try {
+            if (filename.endsWith('.ts') || filename.endsWith('.cts')) {
+                if (process[Symbol.for('ts-node.register.instance')]) {
+                    if (process.env.TS_NODE_DEV) realRequire('ts-node-dev');
+                } else realRequire('ts-node/register');
+                worker = realRequire(decodeURIComponent(filename.replace('win32' === process.platform ? 'file:///' : 'file://', '')));
+            } else worker = await realImport(filename);
+        } catch (error) {
+            if (('ENOTDIR' === error.code || 'ERR_MODULE_NOT_FOUND' === error.code) && filename.startsWith('file://')) worker = realRequire(decodeURIComponent(filename.replace('file://', '')));
+            else if (void 0 === error.code || 'ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING' === error.code) try {
+                worker = realRequire(decodeURIComponent(filename.replace('win32' === process.platform ? 'file:///' : 'file://', '')));
+            } catch  {
+                throw error;
+            }
+            else throw error;
+        }
+        if ('object' == typeof worker) worker = worker.default;
+        if ('object' == typeof worker) worker = worker.default;
+        destination = await worker(workerData.workerData);
+        destination.on('error', function(err) {
+            Atomics.store(state, WRITE_INDEX, -2);
+            Atomics.notify(state, WRITE_INDEX);
+            Atomics.store(state, READ_INDEX, -2);
+            Atomics.notify(state, READ_INDEX);
+            parentPort.postMessage({
+                code: 'ERROR',
+                err
+            });
+        });
+        destination.on('close', function() {
+            const end = Atomics.load(state, WRITE_INDEX);
+            Atomics.store(state, READ_INDEX, end);
+            Atomics.notify(state, READ_INDEX);
+            setImmediate(()=>{
+                process.exit(0);
+            });
+        });
+    }
+    start().then(function() {
+        parentPort.postMessage({
+            code: 'READY'
+        });
+        process.nextTick(run);
+    });
+    function run() {
+        const current = Atomics.load(state, READ_INDEX);
+        const end = Atomics.load(state, WRITE_INDEX);
+        if (end === current) return void (end === data.length ? waitDiff(state, READ_INDEX, end, 1 / 0, run) : waitDiff(state, WRITE_INDEX, end, 1 / 0, run));
+        if (-1 === end) return void destination.end();
+        const toWrite = data.toString('utf8', current, end);
+        const res = destination.write(toWrite);
+        if (res) {
+            Atomics.store(state, READ_INDEX, end);
+            Atomics.notify(state, READ_INDEX);
+            setImmediate(run);
+        } else destination.once('drain', function() {
+            Atomics.store(state, READ_INDEX, end);
+            Atomics.notify(state, READ_INDEX);
+            run();
+        });
+    }
+    process.on('unhandledRejection', function(err) {
+        parentPort.postMessage({
+            code: 'ERROR',
+            err
+        });
+        process.exit(1);
+    });
+    process.on('uncaughtException', function(err) {
+        parentPort.postMessage({
+            code: 'ERROR',
+            err
+        });
+        process.exit(1);
+    });
+    process.once('exit', (exitCode)=>{
+        if (0 !== exitCode) return void process.exit(exitCode);
+        if (destination?.writableNeedDrain && !destination?.writableEnded) parentPort.postMessage({
+            code: 'WARNING',
+            err: new Error('ThreadStream: process exited before destination stream was drained. this may indicate that the destination stream try to write to a another missing stream')
+        });
+        process.exit(0);
+    });
+})();
+module.exports = __webpack_exports__;

package/package.json

@@ -1,25 +1,51 @@
 {
   "name": "@rife/logger",
-  "version": "0.0.5-beta.9",
+  "version": "0.0.6-beta.3",
   "description": "",
-  "main": "./dist/index.js",
+  "type": "module",
   "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/esm/index.mjs"
+    },
+    "./pino": {
+      "types": "./src/pino/index.ts",
+      "require": "./dist/cjs/pino/index.cjs",
+      "import": "./dist/esm/pino/index.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "pino": [
+        "./src/pino"
+      ]
+    }
+  },
   "files": [
     "dist/**/*",
     "src/**/*",
     "tsconfig.json"
   ],
   "dependencies": {
-    "chalk": "4",
-    "nanoid": "^3.3.6",
-    "safe-stable-stringify": "^2.4.3",
-    "winston": "^3.9.0",
-    "winston-daily-rotate-file": "^4.7.1",
-    "@rife/config": "0.0.5-beta.9"
+    "pino": "^9.7.0",
+    "pino-http": "^10.5.0",
+    "pino-pretty": "^13.0.0",
+    "pino-std-serializers": "^7.0.0",
+    "rotating-file-stream": "^3.2.6"
+  },
+  "devDependencies": {
+    "thread-stream": "*",
+    "@rife/cli": "0.0.6-beta.9",
+    "@rife/plugin-rstack": "0.0.1-beta.1"
   },
   "scripts": {
-    "dev": "infra dev",
-    "build": "infra build",
-    "prepublish": "infra build"
+    "dev": "rife dev",
+    "build": "rife build",
+    "lint": "eslint . --fix",
+    "release": "rife release",
+    "dev2": "rife dev --name app2",
+    "build2": "rife build --name app2"
   }
 }

package/src/common.ts

@@ -0,0 +1,4 @@
+import path from 'path';
+
+export const isEsm = path.extname(__filename) === '.mjs';
+export const isCjs = !isEsm;

package/src/env.ts

@@ -0,0 +1,3 @@
+export const isProd = () => process.env.NODE_ENV === 'production';
+
+export const isDev = () => !isProd();

package/src/index.ts

@@ -1,194 +1 @@
-import path from 'path';
-import { AsyncLocalStorage } from 'async_hooks';
-
-import chalk from 'chalk';
-import { customAlphabet } from 'nanoid';
-import winston from 'winston';
-import JSONStringify from 'safe-stable-stringify';
-import 'winston-daily-rotate-file';
-
-export type { winston };
-
-const als = new AsyncLocalStorage<{ traceId: string } & any>();
-
-const isDev = () => process.env.NODE_ENV === 'development';
-const isProd = () => !isDev();
-
-// https://github.com/CyberAP/nanoid-dictionary/blob/master/src/nolookalikes.js
-export const getNewTraceId = customAlphabet('346789ABCDEFGHJKLMNPQRTUVWXYabcdefghijkmnpqrtwxyz', 5);
-
-export function runInTrace<T>(fn: (...args: any[]) => T): T {
-    return als.run({ traceId: getNewTraceId() }, fn);
-}
-
-export function getTraceId() {
-    return als.getStore()?.traceId;
-}
-
-const levelColor = {
-    info: chalk.green,
-    error: chalk.redBright,
-    warn: chalk.yellow,
-};
-
-const levelSymbolMap = {
-    info: 'INF',
-    warn: 'WRN',
-    error: 'ERR',
-};
-
-// 设置traceId
-// https://www.npmjs.com/package/cls-rtracer
-const tracerFormat = (options: { writeToFile: boolean; format: { time: boolean } }) =>
-    winston.format.printf(info => {
-        let traceId = getTraceId();
-        const color = (message: string, chalk: chalk.Chalk) => (options.writeToFile ? message : chalk(message));
-        const levelit = (text: string) => {
-            switch (info.level) {
-                case 'info': {
-                    return color(text, levelColor.info);
-                }
-                case 'warn': {
-                    return color(text, levelColor.warn);
-                }
-                case 'error': {
-                    return color(text, levelColor.error);
-                }
-            }
-            return text;
-        };
-        const levelSymbol = levelSymbolMap[info.level as keyof typeof levelSymbolMap];
-        const level = levelSymbol ? levelit(` [${levelSymbol}]`) : '';
-        const service = info.metadata.service ? levelit(` [${info.metadata.service}]`) : '';
-        const timestamp = options.format.time ? color(info.timestamp, chalk.gray) : '';
-        const trace = traceId ? color(` [${traceId}]`, chalk.gray) : '';
-        let message = info.message || '';
-        if (typeof info?.message !== 'string') {
-            try {
-                if (isDev()) {
-                    message = '\n' + JSONStringify(info?.message, undefined, 4);
-                } else {
-                    message = JSONStringify(info?.message, undefined, 0);
-                }
-            } catch (e) {
-                message = 'fail to stringify json';
-            }
-        }
-        message = ' ' + message;
-        const stack = info.metadata.stack ? color('\n' + info.metadata.stack + '\n', chalk.gray) : '';
-        return `${timestamp}${trace}${level}${service}${message}${stack}`;
-    });
-
-export namespace Logger {
-    export interface Options {
-        /**
-         * 输出日志到console
-         * 默认：development环境下输出，production环境下不输出
-         */
-        writeToConsole?: boolean;
-
-        /**
-         * 输出日志到文件
-         * 默认：development环境下输出，production环境下不输出
-         */
-        writeToFile?: boolean;
-
-        /**
-         * 输出日志的文件目录
-         * 默认：./logs/
-         */
-        dirname?: string;
-
-        /**
-         * 输出日志的文件名
-         * 默认：server
-         */
-        filename?: string;
-
-        /**
-         * 日志输出格式
-         */
-        format?: {
-            /**
-             * 显示时间
-             * 默认：true
-             */
-            time?: boolean;
-
-            /**
-             * 显示traceId
-             * 默认：true
-             */
-            traceId?: boolean;
-        };
-    }
-}
-
-export interface Logger {
-    info: winston.LeveledLogMethod;
-    warn: winston.LeveledLogMethod;
-    error: winston.LeveledLogMethod;
-    setMetaData: (data: any) => void;
-}
-
-export function createLogger(options?: Logger.Options) {
-    let transports: winston.transport[] = [];
-    let config = {
-        writeToConsole: options?.writeToConsole ?? isDev(),
-        writeToFile: options?.writeToFile ?? isProd(),
-        dirname: options?.dirname || path.join(process.cwd(), './logs/'),
-        filename: options?.filename || 'server',
-        format: {
-            time: options?.format?.time ?? true,
-        },
-    };
-    if (config.writeToFile) {
-        transports.push(
-            new winston.transports.DailyRotateFile({
-                // https://www.npmjs.com/package/winston-daily-rotate-file
-                filename: config.filename,
-                dirname: config.dirname,
-                datePattern: 'YYYY-MM-DD',
-                maxFiles: '30d',
-                extension: '.log',
-            }),
-        );
-    }
-
-    if (config.writeToConsole) {
-        transports.push(new winston.transports.Console());
-    }
-
-    const { combine, timestamp, colorize, errors, metadata, splat } = winston.format;
-    const timeFormat = isProd() ? 'YYYY-MM-DD HH:mm:ss.SSS' : 'HH:mm:ss.SSS';
-    let format: winston.Logform.Format[] = [
-        errors({ stack: true }),
-        metadata(),
-        timestamp({ format: timeFormat }),
-        splat(), // https://github.com/winstonjs/logform/blob/master/splat.js
-        tracerFormat(config),
-    ];
-    if (!config.writeToFile) {
-        format.push(colorize());
-    }
-    const instance = winston.createLogger({
-        format: combine(...format),
-        transports,
-    });
-
-    const setMetaData = (data: any) => {
-        instance.defaultMeta = {
-            ...instance.defaultMeta,
-            ...data,
-        };
-    };
-
-    const logger: Logger = {
-        info: instance.info.bind(instance),
-        warn: instance.warn.bind(instance),
-        error: instance.error.bind(instance),
-        setMetaData,
-    };
-
-    return { logger };
-}
+export * from './trace';

package/src/pino/index.ts

@@ -0,0 +1,91 @@
+import path from 'path';
+
+import pino from 'pino';
+
+import { isEsm } from '../common';
+import { genTraceId, getTraceId, runInTrace } from '../trace';
+
+declare var PINO_RSPACK_PLUGIN: any;
+
+// https://github.com/pinojs/pino/blob/master/docs/api.md
+function getPinoConfig() {
+    const targets: any = [];
+
+    if (typeof PINO_RSPACK_PLUGIN !== 'undefined') {
+        // 打包单文件的时候自动拷贝worker
+        (globalThis as any).__bundlerPathsOverrides = {
+            'pino-pretty': path.join(__dirname, './worker/pino-pretty.cjs'),
+            'pino-worker': path.join(__dirname, './worker/pino-worker.cjs'),
+            './rotate.cjs': path.join(__dirname, './worker/pino-rotate.cjs'),
+            'pino/file': path.join(__dirname, './worker/pino-file.cjs'),
+            'thread-stream-worker': path.join(__dirname, './worker/thread-stream.cjs'),
+            ...(globalThis as any).__bundlerPathsOverrides,
+        };
+    }
+
+    if (process.env.NODE_ENV === 'production') {
+    } else {
+        targets.push({
+            level: 'debug',
+            target: 'pino-pretty', // must be installed separately,
+            options: {},
+        });
+    }
+
+    targets.push({
+        level: 'debug',
+        target: `./rotate${isEsm ? '.mjs' : '.cjs'}`,
+        options: { path: './logs/' },
+    });
+
+    const config: pino.LoggerOptions = {
+        transport: { targets },
+        mixin(data: any) {
+            // {"level":30,"time":1726065716643,"pid":21968,"hostname":"Win-LH"}
+            // 基础字段不能重复 删除掉
+            delete data.level;
+            delete data.time;
+            delete data.pid;
+            delete data.hostname;
+            if (!data?.traceId) {
+                return { traceId: getTraceId() };
+            }
+            return {};
+        },
+    };
+
+    return config;
+}
+
+export function createLogger() {
+    const logger = pino({
+        ...getPinoConfig(),
+    });
+
+    return { logger };
+}
+
+export function express(logger: any) {
+    const { mapHttpRequest, mapHttpResponse } = require('pino-std-serializers') as typeof import('pino-std-serializers');
+
+    return (req: any, res: any, next: any) => {
+        const response: any = res;
+        response[startTime] = response[startTime] || Date.now();
+        const traceId = req.headers['trace-id'] || genTraceId();
+
+        const onComplete = () => {
+            res.removeListener('close', onComplete);
+            res.removeListener('finish', onComplete);
+            res.removeListener('error', onComplete);
+            const duration = Date.now() - response[startTime];
+
+            logger.info({ duration, request: mapHttpRequest(req).req, response: mapHttpResponse(res).res }, 'request');
+        };
+
+        res.on('close', onComplete);
+        res.on('finish', onComplete);
+        res.on('error', onComplete);
+
+        runInTrace({ traceId }, next);
+    };
+}

package/src/pino/rotate.ts

@@ -0,0 +1,32 @@
+import type { Options } from 'rotating-file-stream';
+
+export interface PinoRotatingFileStreamOptions extends Options {
+    path: string;
+}
+
+const generator = (time: number | Date, index?: number) => {
+    if (!time) {
+        return 'server.log';
+    }
+    time = new Date(time);
+
+    const month = String(time.getMonth() + 1).padStart(2, '0');
+    const day = String(time.getDate()).padStart(2, '0');
+    if (index) {
+        const count = String(index).padStart(3, '0');
+        return `server.${time.getFullYear()}${month}${day}-${count}.log`;
+    }
+    return `server.${time.getFullYear()}${month}${day}.log`;
+};
+
+export default (options: PinoRotatingFileStreamOptions) => {
+    const { createStream } = require('rotating-file-stream') as typeof import('rotating-file-stream');
+
+    const { path } = options;
+    return createStream(generator, {
+        size: '50M',
+        maxSize: '500M',
+        interval: '1d',
+        path,
+    });
+};

package/src/test.ts

@@ -1,25 +1,12 @@
-process.env.NODE_ENV = 'development';
-// process.env.NODE_ENV = 'production';
-
-import { createLogger } from '.';
-
-const { logger } = createLogger({ writeToFile: false, writeToConsole: true, format: { time: false } });
-
-const deep = { a: { b: { c: { g: { e: { f: 1 } } } } } };
-logger.info('1 %s', { a: 1 });
-logger.info('2 %j', deep);
-logger.info('3 \n%j', deep);
-logger.info('4 %s %s', 1, 2);
-logger.info('5 %o', deep);
-logger.info(deep);
-logger.warn('execed');
-logger.error(new Error('not found'));
-
-// import { format } from 'logform';
-
-// const jsonFormat = format.json({ space: 2 });
-// const info = jsonFormat.transform({
-//     level: 'info',
-//     message: 'my message',
-// });
-// console.log(info);
+process.env.NODE_ENV = 'development';
+// process.env.NODE_ENV = 'production';
+
+import { createLogger } from './pino';
+import { genTraceId } from './trace';
+
+const { logger } = createLogger();
+
+logger.info({ a: 999 }, '123    2            ');
+
+const start = performance.now();
+logger.info({ duration: performance.now() - start, id: genTraceId() });

package/src/trace.ts

@@ -0,0 +1,15 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+const als = new AsyncLocalStorage<{ traceId: string } & any>();
+
+export function runInTrace<T>(data: any, fn: (...args: any[]) => T): T {
+    return als.run(data, fn);
+}
+
+export function genTraceId() {
+    return crypto.randomUUID().replaceAll('-', '');
+}
+
+export function getTraceId() {
+    return als.getStore()?.traceId;
+}

package/src/worker.ts

@@ -0,0 +1 @@
+import 'thread-stream/lib/worker';

package/tsconfig.json

@@ -1,12 +1,12 @@
-{
-    "extends": "@rife/config/tsconfig.json", // 继承 packages 目录下通用配置
-    "compilerOptions": {
-        "outDir": "dist",
-        "declaration": true,
-        "baseUrl": ".",
-        "paths": {
-            "@/*": ["./src/*"]
-        }
-    },
-    "include": ["./src/**/*"]
-}
+{
+    "extends": "@rife/config/tsconfig.json", // 继承 packages 目录下通用配置
+    "compilerOptions": {
+        "outDir": "dist",
+        "declaration": true,
+        "baseUrl": ".",
+        "paths": {
+            "@/*": ["./src/*"]
+        }
+    },
+    "include": ["./src/**/*"]
+}