@rife/logger 0.0.6-beta.10 → 0.0.6-beta.12

package/dist/esm/pino/worker/thread-stream.cjs

@@ -0,0 +1,174 @@
+"use strict";
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/real-require@0.2.0/node_modules/real-require/src/index.js" (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@4.0.0/node_modules/thread-stream/lib/indexes.js" (module1) {
+        "use strict";
+        const WRITE_INDEX = 4;
+        const READ_INDEX = 8;
+        module1.exports = {
+            WRITE_INDEX,
+            READ_INDEX
+        };
+    },
+    "../../node_modules/.pnpm/thread-stream@4.0.0/node_modules/thread-stream/lib/wait.js" (module1) {
+        "use strict";
+        const WAIT_MS = 10000;
+        function wait(state, index, expected, timeout, done) {
+            const max = timeout === 1 / 0 ? 1 / 0 : Date.now() + timeout;
+            const check = ()=>{
+                const current = Atomics.load(state, index);
+                if (current === expected) return void done(null, 'ok');
+                if (max !== 1 / 0 && Date.now() > max) return void done(null, 'timed-out');
+                const remaining = max === 1 / 0 ? WAIT_MS : Math.min(WAIT_MS, Math.max(1, max - Date.now()));
+                const result = Atomics.waitAsync(state, index, current, remaining);
+                if (result.async) result.value.then(check);
+                else setImmediate(check);
+            };
+            check();
+        }
+        function waitDiff(state, index, expected, timeout, done) {
+            const max = timeout === 1 / 0 ? 1 / 0 : Date.now() + timeout;
+            const check = ()=>{
+                const current = Atomics.load(state, index);
+                if (current !== expected) return void done(null, 'ok');
+                if (max !== 1 / 0 && Date.now() > max) return void done(null, 'timed-out');
+                const remaining = max === 1 / 0 ? WAIT_MS : Math.min(WAIT_MS, Math.max(1, max - Date.now()));
+                const result = Atomics.waitAsync(state, index, expected, remaining);
+                if (result.async) result.value.then(check);
+                else setImmediate(check);
+            };
+            check();
+        }
+        module1.exports = {
+            wait,
+            waitDiff
+        };
+    },
+    worker_threads (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@4.0.0/node_modules/thread-stream/lib/indexes.js");
+    const { waitDiff } = __webpack_require__("../../node_modules/.pnpm/thread-stream@4.0.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);
+    const keepAlive = setInterval(()=>{}, 3600000);
+    async function start() {
+        let worker;
+        try {
+            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 if (filename.endsWith('.ts') || filename.endsWith('.cts')) try {
+                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://', '')));
+            } 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);
+            clearInterval(keepAlive);
+            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/esm/test.mjs

@@ -1,7 +1,7 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { createLogger } from "./pino/index.mjs";
-import { genTraceId } from "./trace.mjs";
+import { genTraceId, runInTrace } from "./trace.mjs";
 process.env.NODE_ENV = 'development';
 const { logger } = createLogger();
 logger.info({
@@ -18,11 +18,6 @@ const log = logger.child({
 }, {
     msgPrefix: '[123] '
 });
-log.info(2);
-log.info({
-    c: 1,
-    name: '========'
-}, 'name overide');
 log.error(new Error('cause', {
     cause: new Error('789')
 }));
@@ -30,3 +25,12 @@ log.error({
     error: new Error('error data'),
     data: 2
 });
+log.info({
+    c: 1,
+    name: '========'
+}, 'name overide');
+runInTrace({
+    traceId: genTraceId()
+}, ()=>{
+    log.info(1);
+});