@rife/logger 0.0.6-beta.1 → 0.0.6-beta.11

package/dist/cjs/pino/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/dist/cjs/test.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __webpack_exports__ = {};
+const index_cjs_namespaceObject = require("./pino/index.cjs");
+const external_trace_cjs_namespaceObject = require("./trace.cjs");
+process.env.NODE_ENV = 'development';
+const { logger } = (0, index_cjs_namespaceObject.createLogger)();
+logger.info({
+    a: 999
+}, '1');
+const start = performance.now();
+logger.info({
+    duration: Math.round(performance.now() - start),
+    traceId: (0, external_trace_cjs_namespaceObject.genTraceId)()
+});
+const log = logger.child({
+    name: 'name123',
+    traceId: (0, external_trace_cjs_namespaceObject.genTraceId)()
+}, {
+    msgPrefix: '[123] '
+});
+log.error(new Error('cause', {
+    cause: new Error('789')
+}));
+log.error({
+    error: new Error('error data'),
+    data: 2
+});
+log.info({
+    c: 1,
+    name: '========'
+}, 'name overide');
+log.info(1);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/trace.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    runInTrace: ()=>runInTrace,
+    getTraceId: ()=>getTraceId,
+    genTraceId: ()=>genTraceId
+});
+const external_async_hooks_namespaceObject = require("async_hooks");
+const als = new external_async_hooks_namespaceObject.AsyncLocalStorage();
+function runInTrace(data, fn) {
+    return als.run(data, fn);
+}
+function genTraceId() {
+    return crypto.randomUUID().replaceAll('-', '');
+}
+function getTraceId() {
+    return als.getStore()?.traceId;
+}
+exports.genTraceId = __webpack_exports__.genTraceId;
+exports.getTraceId = __webpack_exports__.getTraceId;
+exports.runInTrace = __webpack_exports__.runInTrace;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "genTraceId",
+    "getTraceId",
+    "runInTrace"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/common.mjs

@@ -0,0 +1,8 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { fileURLToPath as __webpack_fileURLToPath__ } from "node:url";
+import path from "path";
+var common_filename = __webpack_fileURLToPath__(import.meta.url);
+const isEsm = '.mjs' === path.extname(common_filename);
+const isCjs = !isEsm;
+export { isCjs, isEsm };

package/dist/esm/env.mjs

@@ -0,0 +1,5 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+const isProd = ()=>'production' === process.env.NODE_ENV;
+const isDev = ()=>!isProd();
+export { isDev, isProd };

package/dist/esm/index.mjs

@@ -0,0 +1,3 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+export * from "./trace.mjs";

package/dist/esm/pino/index.mjs

@@ -0,0 +1,116 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { fileURLToPath as __webpack_fileURLToPath__ } from "node:url";
+import { dirname as __webpack_dirname__ } from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_pino_std_serializers_719fa64c__ from "pino-std-serializers";
+import path from "path";
+import pino from "pino";
+import { genTraceId, getTraceId, runInTrace } from "../trace.mjs";
+var __webpack_modules__ = {
+    "pino-std-serializers": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_pino_std_serializers_719fa64c__;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+var pino_filename = __webpack_fileURLToPath__(import.meta.url);
+var pino_dirname = __webpack_dirname__(__webpack_fileURLToPath__(import.meta.url));
+function getPinoConfig() {
+    const targets = [];
+    const rotate = `./rotate${path.extname(pino_filename)}`;
+    targets.push({
+        level: 'debug',
+        target: rotate,
+        options: {
+            path: './logs/'
+        }
+    });
+    if ('undefined' != typeof __isNodeSingleFileBundle || 'undefined' != typeof __isVite || global?.__remix_devServerHooks || 'development' !== process.env.NODE_ENV) globalThis.__bundlerPathsOverrides = {
+        'pino-pretty': path.join(pino_dirname, './worker/pino-pretty.cjs'),
+        'pino-worker': path.join(pino_dirname, './worker/pino-worker.cjs'),
+        [rotate]: path.join(pino_dirname, './worker/pino-rotate.cjs'),
+        'pino/file': path.join(pino_dirname, './worker/pino-file.cjs'),
+        'thread-stream-worker': path.join(pino_dirname, './worker/thread-stream.cjs'),
+        ...globalThis.__bundlerPathsOverrides
+    };
+    'production' === process.env.NODE_ENV || targets.push({
+        level: 'debug',
+        target: 'pino-pretty',
+        options: {
+            ignore: 'pid',
+            messageKey: 'message'
+        }
+    });
+    const config = {
+        transport: {
+            targets
+        },
+        mixin (data) {
+            delete data.level;
+            delete data.time;
+            delete data.pid;
+            delete data.name;
+            delete data.hostname;
+            if (!data?.traceId) return {
+                traceId: getTraceId()
+            };
+            return {};
+        }
+    };
+    return config;
+}
+function createLogger() {
+    const logger = pino({
+        base: {
+            pid: process.pid
+        },
+        messageKey: 'message',
+        errorKey: 'error',
+        timestamp: pino.stdTimeFunctions.epochTime,
+        ...getPinoConfig()
+    });
+    return {
+        logger
+    };
+}
+function useExpress(logger, format) {
+    const serializers = __webpack_require__("pino-std-serializers");
+    const mapHttpRequest = serializers.mapHttpRequest;
+    const mapHttpResponse = serializers.mapHttpResponse || serializers.default.mapHttpResponse;
+    const startTime = Symbol();
+    return (req, res, next)=>{
+        const response = 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];
+            const serializedRequest = mapHttpRequest(req).req;
+            const serializedResponse = mapHttpResponse(res).res;
+            const msg = `${serializedRequest.method} ${serializedRequest.url}`;
+            const info = {
+                duration,
+                request: serializedRequest,
+                response: serializedResponse
+            };
+            logger.info(format?.(info) || info, msg);
+        };
+        res.on('close', onComplete);
+        res.on('finish', onComplete);
+        res.on('error', onComplete);
+        runInTrace({
+            traceId
+        }, next);
+    };
+}
+export { createLogger, useExpress };

package/dist/esm/pino/rotate.mjs

@@ -0,0 +1,40 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import * as __WEBPACK_EXTERNAL_MODULE_rotating_file_stream_66c5ea63__ from "rotating-file-stream";
+var __webpack_modules__ = {
+    "rotating-file-stream": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_rotating_file_stream_66c5ea63__;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const generator = (time, index)=>{
+    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`;
+};
+const rotate = (options)=>{
+    const { createStream } = __webpack_require__("rotating-file-stream");
+    const { path } = options;
+    return createStream(generator, {
+        size: '50M',
+        maxSize: '500M',
+        interval: '1d',
+        path
+    });
+};
+export { rotate as default };