@decohere/scribe-pino 0.0.1-dev.70 → 0.0.1-dev.72

package/commonjs/src/pino.adapater.js

@@ -76,17 +76,28 @@ class PinoAdapter extends _scribe.LogAdapter {
             return;
         }
         this.disposed = true;
-        if (this._pino && !this.retired) {
-            await new Promise((resolve)=>{
-                try {
-                    this._pino.flush(()=>resolve());
-                } catch  {
-                    resolve();
-                }
-            });
-        }
         if (!this.retired) {
-            await endDestination(this.stream);
+            const dest = this.stream;
+            if (dest != null && typeof dest.end === "function") {
+                // pino.transport() is a ThreadStream: pino.flush() → Atomics.waitAsync can
+                // hang forever after concurrent writes. end() flushSyncs then signals
+                // finish/close (it does not accept a Node Writable callback).
+                await endDestination(dest);
+            } else if (this._pino) {
+                await new Promise((resolve, reject)=>{
+                    try {
+                        this._pino.flush((err)=>{
+                            if (err != null) {
+                                reject(err);
+                                return;
+                            }
+                            resolve();
+                        });
+                    } catch (err) {
+                        reject(err instanceof Error ? err : new Error(String(err)));
+                    }
+                });
+            }
         }
         // Mark dead after graceful end (or immediately if already force-retired).
         this.retire();
@@ -102,16 +113,57 @@ function destroyDestination(stream) {
         }
     }
 }
-function endDestination(stream) {
-    const endable = stream;
-    if (typeof endable?.end !== "function") {
+/**
+ * Drain a pino destination.
+ *
+ * Node `Writable.end(cb)` invokes `cb`. `pino.transport()` returns a
+ * ThreadStream whose `end()` takes no callback and signals via `finish`/`close`
+ * instead — waiting only on `end(cb)` hangs forever and blocks Flux HMR.
+ */ function endDestination(stream) {
+    if (typeof stream.end !== "function") {
         return Promise.resolve();
     }
-    return new Promise((resolve)=>{
-        try {
-            endable.end(()=>resolve());
-        } catch  {
+    if (stream.destroyed || stream.closed || stream.writableFinished) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        const settle = (err)=>{
+            if (settled) {
+                return;
+            }
+            settled = true;
+            stream.off?.("finish", onFinish);
+            stream.off?.("close", onClose);
+            stream.off?.("error", onError);
+            if (err != null) {
+                reject(err);
+                return;
+            }
             resolve();
+        };
+        const onFinish = ()=>settle();
+        const onClose = ()=>settle();
+        const onError = (err)=>{
+            // ThreadStream may emit error then close during teardown; closed = done.
+            if (stream.destroyed || stream.closed) {
+                settle();
+                return;
+            }
+            settle(err);
+        };
+        stream.once?.("finish", onFinish);
+        stream.once?.("close", onClose);
+        stream.once?.("error", onError);
+        try {
+            stream.end((err)=>settle(err));
+        } catch (err) {
+            settle(err instanceof Error ? err : new Error(String(err)));
+            return;
+        }
+        // ThreadStream.end() is a no-op when already destroyed (no events).
+        if (stream.destroyed || stream.closed || stream.writableFinished) {
+            settle();
         }
     });
 }
@@ -155,4 +207,4 @@ function pinoMix(logger) {
     });
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe-pino/src/pino.adapater.ts"],"sourcesContent":["import {\n\ttype BaseLogger,\n\tformatError,\n\tLogAdapter,\n\ttype Logger,\n\ttype ScribeOptions,\n} from \"@decohere/scribe\";\nimport pino, { type LogFn } from \"pino\";\n\nimport type { GuardedTransport } from \"./pino.transport-guard.js\";\n\nexport type PinoAdapaterOptions = {\n\toptions?: pino.LoggerOptions;\n\tstream?: pino.DestinationStream;\n};\n\ntype EndableStream = {\n\tend?: (cb?: (err?: Error | null) => void) => void;\n\tdestroy?: (error?: Error) => void;\n};\n\nexport class PinoAdapter extends LogAdapter {\n\tprivate _pino: pino.Logger;\n\tprivate readonly options: pino.LoggerOptions;\n\tprivate readonly stream: pino.DestinationStream | undefined;\n\tprivate disposed = false;\n\tprivate retired = false;\n\n\tpublic constructor(options: pino.LoggerOptions, stream?: pino.DestinationStream) {\n\t\tsuper();\n\t\tthis.options = options;\n\t\tthis.stream = stream;\n\t}\n\n\tpublic configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tscribeOptions: ScribeOptions<T, CustomOnly>,\n\t) {\n\t\tconst { logLevel, redactions } = scribeOptions;\n\t\tconst customLevels = this.getLogLevels(scribeOptions);\n\n\t\tconst pinoOptions: pino.LoggerOptions = {\n\t\t\tcustomLevels,\n\t\t\tlevel: logLevel,\n\t\t\thooks: { logMethod },\n\t\t\tserializers: {\n\t\t\t\terror: pino.stdSerializers.err,\n\t\t\t},\n\t\t\tredact: redactions,\n\t\t\t...this.options,\n\t\t};\n\t\tthis._pino = pino(pinoOptions, this.stream);\n\t}\n\n\tpublic getLogger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname: string,\n\t): Logger<T, CustomOnly> {\n\t\tconst logger = pinoMix<T, CustomOnly>(this._pino.child({ name }));\n\t\treturn logger;\n\t}\n\n\tpublic flush(cb?: () => void): void {\n\t\tif (this.retired || !this._pino) {\n\t\t\tcb?.();\n\t\t\treturn;\n\t\t}\n\t\tthis._pino.flush(cb);\n\t}\n\n\t/**\n\t * Immediately stop accepting writes into the destination (ThreadStream).\n\t * Does not wait for flush — use `stop()` for async drain after retire.\n\t */\n\tpublic retire(): void {\n\t\tif (this.retired) {\n\t\t\treturn;\n\t\t}\n\t\tthis.retired = true;\n\t\tconst guarded = this.stream as GuardedTransport | undefined;\n\t\tif (typeof guarded?.retire === \"function\") {\n\t\t\tguarded.retire(\"adapter retired\");\n\t\t\treturn;\n\t\t}\n\t\tdestroyDestination(this.stream);\n\t}\n\n\tpublic async [Symbol.asyncDispose](): Promise<void> {\n\t\tif (this.disposed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.disposed = true;\n\t\tif (this._pino && !this.retired) {\n\t\t\tawait new Promise<void>((resolve) => {\n\t\t\t\ttry {\n\t\t\t\t\tthis._pino.flush(() => resolve());\n\t\t\t\t} catch {\n\t\t\t\t\tresolve();\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\tif (!this.retired) {\n\t\t\tawait endDestination(this.stream);\n\t\t}\n\t\t// Mark dead after graceful end (or immediately if already force-retired).\n\t\tthis.retire();\n\t}\n}\n\nfunction destroyDestination(stream: pino.DestinationStream | undefined): void {\n\tconst destroyable = stream as EndableStream | undefined;\n\tif (typeof destroyable?.destroy === \"function\") {\n\t\ttry {\n\t\t\tdestroyable.destroy();\n\t\t} catch {\n\t\t\t// already dead\n\t\t}\n\t}\n}\n\nfunction endDestination(stream: pino.DestinationStream | undefined): Promise<void> {\n\tconst endable = stream as EndableStream | undefined;\n\tif (typeof endable?.end !== \"function\") {\n\t\treturn Promise.resolve();\n\t}\n\treturn new Promise<void>((resolve) => {\n\t\ttry {\n\t\t\tendable.end(() => resolve());\n\t\t} catch {\n\t\t\tresolve();\n\t\t}\n\t});\n}\n\nfunction logMethod(this: pino.Logger, args: Parameters<LogFn>, method: LogFn) {\n\tlet message = args.at(0);\n\tconst data = args.at(1);\n\n\tif (message instanceof Error) {\n\t\tmethod.call(this, { err: message }, formatError(message));\n\t\treturn;\n\t}\n\n\tif (data instanceof Error) {\n\t\tmessage = { msg: message, ...{ error: data } };\n\t} else if (typeof data === \"object\") {\n\t\tmessage = { msg: message, ...data };\n\t} else {\n\t\tmessage = { msg: message, data };\n\t}\n\n\tmethod.call(this, message);\n}\n\nfunction pinoMix<T extends string = never, CustomOnly extends true | false = false>(\n\tlogger: pino.Logger,\n): Logger<T, CustomOnly> {\n\treturn Object.assign<pino.Logger, BaseLogger>(logger, {\n\t\tget currentLevel() {\n\t\t\treturn logger.level;\n\t\t},\n\t\tget logLevels() {\n\t\t\treturn logger.levels.values;\n\t\t},\n\t}) as Logger<T, CustomOnly>;\n}\n"],"names":["PinoAdapter","LogAdapter","_pino","options","stream","disposed","retired","configure","scribeOptions","logLevel","redactions","customLevels","getLogLevels","pinoOptions","level","hooks","logMethod","serializers","error","pino","stdSerializers","err","redact","getLogger","name","logger","pinoMix","child","flush","cb","retire","guarded","destroyDestination","Symbol","asyncDispose","Promise","resolve","endDestination","destroyable","destroy","endable","end","args","method","message","at","data","Error","call","formatError","msg","Object","assign","currentLevel","logLevels","levels","values"],"mappings":";;;;+BAqBaA;;;eAAAA;;;wBAfN;6DAC0B;;;;;;AAc1B,MAAMA,oBAAoBC,kBAAU;IAClCC,MAAmB;IACVC,QAA4B;IAC5BC,OAA2C;IACpDC,WAAW,MAAM;IACjBC,UAAU,MAAM;IAExB,YAAmBH,OAA2B,EAAEC,MAA+B,CAAE;QAChF,KAAK;QACL,IAAI,CAACD,OAAO,GAAGA;QACf,IAAI,CAACC,MAAM,GAAGA;IACf;IAEOG,UACNC,aAA2C,EAC1C;QACD,MAAM,EAAEC,QAAQ,EAAEC,UAAU,EAAE,GAAGF;QACjC,MAAMG,eAAe,IAAI,CAACC,YAAY,CAACJ;QAEvC,MAAMK,cAAkC;YACvCF;YACAG,OAAOL;YACPM,OAAO;gBAAEC;YAAU;YACnBC,aAAa;gBACZC,OAAOC,aAAI,CAACC,cAAc,CAACC,GAAG;YAC/B;YACAC,QAAQZ;YACR,GAAG,IAAI,CAACP,OAAO;QAChB;QACA,IAAI,CAACD,KAAK,GAAGiB,IAAAA,aAAI,EAACN,aAAa,IAAI,CAACT,MAAM;IAC3C;IAEOmB,UACNC,IAAY,EACY;QACxB,MAAMC,SAASC,QAAuB,IAAI,CAACxB,KAAK,CAACyB,KAAK,CAAC;YAAEH;QAAK;QAC9D,OAAOC;IACR;IAEOG,MAAMC,EAAe,EAAQ;QACnC,IAAI,IAAI,CAACvB,OAAO,IAAI,CAAC,IAAI,CAACJ,KAAK,EAAE;YAChC2B;YACA;QACD;QACA,IAAI,CAAC3B,KAAK,CAAC0B,KAAK,CAACC;IAClB;IAEA;;;EAGC,GACD,AAAOC,SAAe;QACrB,IAAI,IAAI,CAACxB,OAAO,EAAE;YACjB;QACD;QACA,IAAI,CAACA,OAAO,GAAG;QACf,MAAMyB,UAAU,IAAI,CAAC3B,MAAM;QAC3B,IAAI,OAAO2B,SAASD,WAAW,YAAY;YAC1CC,QAAQD,MAAM,CAAC;YACf;QACD;QACAE,mBAAmB,IAAI,CAAC5B,MAAM;IAC/B;IAEA,MAAa,CAAC6B,OAAOC,YAAY,CAAC,GAAkB;QACnD,IAAI,IAAI,CAAC7B,QAAQ,EAAE;YAClB;QACD;QACA,IAAI,CAACA,QAAQ,GAAG;QAChB,IAAI,IAAI,CAACH,KAAK,IAAI,CAAC,IAAI,CAACI,OAAO,EAAE;YAChC,MAAM,IAAI6B,QAAc,CAACC;gBACxB,IAAI;oBACH,IAAI,CAAClC,KAAK,CAAC0B,KAAK,CAAC,IAAMQ;gBACxB,EAAE,OAAM;oBACPA;gBACD;YACD;QACD;QACA,IAAI,CAAC,IAAI,CAAC9B,OAAO,EAAE;YAClB,MAAM+B,eAAe,IAAI,CAACjC,MAAM;QACjC;QACA,0EAA0E;QAC1E,IAAI,CAAC0B,MAAM;IACZ;AACD;AAEA,SAASE,mBAAmB5B,MAA0C;IACrE,MAAMkC,cAAclC;IACpB,IAAI,OAAOkC,aAAaC,YAAY,YAAY;QAC/C,IAAI;YACHD,YAAYC,OAAO;QACpB,EAAE,OAAM;QACP,eAAe;QAChB;IACD;AACD;AAEA,SAASF,eAAejC,MAA0C;IACjE,MAAMoC,UAAUpC;IAChB,IAAI,OAAOoC,SAASC,QAAQ,YAAY;QACvC,OAAON,QAAQC,OAAO;IACvB;IACA,OAAO,IAAID,QAAc,CAACC;QACzB,IAAI;YACHI,QAAQC,GAAG,CAAC,IAAML;QACnB,EAAE,OAAM;YACPA;QACD;IACD;AACD;AAEA,SAASpB,UAA6B0B,IAAuB,EAAEC,MAAa;IAC3E,IAAIC,UAAUF,KAAKG,EAAE,CAAC;IACtB,MAAMC,OAAOJ,KAAKG,EAAE,CAAC;IAErB,IAAID,mBAAmBG,OAAO;QAC7BJ,OAAOK,IAAI,CAAC,IAAI,EAAE;YAAE3B,KAAKuB;QAAQ,GAAGK,IAAAA,mBAAW,EAACL;QAChD;IACD;IAEA,IAAIE,gBAAgBC,OAAO;QAC1BH,UAAU;YAAEM,KAAKN;YAAS,GAAG;gBAAE1B,OAAO4B;YAAK,CAAC;QAAC;IAC9C,OAAO,IAAI,OAAOA,SAAS,UAAU;QACpCF,UAAU;YAAEM,KAAKN;YAAS,GAAGE,IAAI;QAAC;IACnC,OAAO;QACNF,UAAU;YAAEM,KAAKN;YAASE;QAAK;IAChC;IAEAH,OAAOK,IAAI,CAAC,IAAI,EAAEJ;AACnB;AAEA,SAASlB,QACRD,MAAmB;IAEnB,OAAO0B,OAAOC,MAAM,CAA0B3B,QAAQ;QACrD,IAAI4B,gBAAe;YAClB,OAAO5B,OAAOX,KAAK;QACpB;QACA,IAAIwC,aAAY;YACf,OAAO7B,OAAO8B,MAAM,CAACC,MAAM;QAC5B;IACD;AACD"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe-pino/src/pino.adapater.ts"],"sourcesContent":["import {\n\ttype BaseLogger,\n\tformatError,\n\tLogAdapter,\n\ttype Logger,\n\ttype ScribeOptions,\n} from \"@decohere/scribe\";\nimport pino, { type LogFn } from \"pino\";\n\nimport type { GuardedTransport } from \"./pino.transport-guard.js\";\n\nexport type PinoAdapaterOptions = {\n\toptions?: pino.LoggerOptions;\n\tstream?: pino.DestinationStream;\n};\n\ntype EndableStream = {\n\tend?: (cb?: (err?: Error | null) => void) => void;\n\tdestroy?: (error?: Error) => void;\n\tdestroyed?: boolean;\n\tclosed?: boolean;\n\twritableFinished?: boolean;\n\tonce?: (\n\t\tevent: \"finish\" | \"close\" | \"error\",\n\t\tlistener: (...args: never[]) => void,\n\t) => unknown;\n\toff?: (event: \"finish\" | \"close\" | \"error\", listener: (...args: never[]) => void) => unknown;\n};\n\nexport class PinoAdapter extends LogAdapter {\n\tprivate _pino: pino.Logger;\n\tprivate readonly options: pino.LoggerOptions;\n\tprivate readonly stream: pino.DestinationStream | undefined;\n\tprivate disposed = false;\n\tprivate retired = false;\n\n\tpublic constructor(options: pino.LoggerOptions, stream?: pino.DestinationStream) {\n\t\tsuper();\n\t\tthis.options = options;\n\t\tthis.stream = stream;\n\t}\n\n\tpublic configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tscribeOptions: ScribeOptions<T, CustomOnly>,\n\t) {\n\t\tconst { logLevel, redactions } = scribeOptions;\n\t\tconst customLevels = this.getLogLevels(scribeOptions);\n\n\t\tconst pinoOptions: pino.LoggerOptions = {\n\t\t\tcustomLevels,\n\t\t\tlevel: logLevel,\n\t\t\thooks: { logMethod },\n\t\t\tserializers: {\n\t\t\t\terror: pino.stdSerializers.err,\n\t\t\t},\n\t\t\tredact: redactions,\n\t\t\t...this.options,\n\t\t};\n\t\tthis._pino = pino(pinoOptions, this.stream);\n\t}\n\n\tpublic getLogger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname: string,\n\t): Logger<T, CustomOnly> {\n\t\tconst logger = pinoMix<T, CustomOnly>(this._pino.child({ name }));\n\t\treturn logger;\n\t}\n\n\tpublic flush(cb?: () => void): void {\n\t\tif (this.retired || !this._pino) {\n\t\t\tcb?.();\n\t\t\treturn;\n\t\t}\n\t\tthis._pino.flush(cb);\n\t}\n\n\t/**\n\t * Immediately stop accepting writes into the destination (ThreadStream).\n\t * Does not wait for flush — use `stop()` for async drain after retire.\n\t */\n\tpublic retire(): void {\n\t\tif (this.retired) {\n\t\t\treturn;\n\t\t}\n\t\tthis.retired = true;\n\t\tconst guarded = this.stream as GuardedTransport | undefined;\n\t\tif (typeof guarded?.retire === \"function\") {\n\t\t\tguarded.retire(\"adapter retired\");\n\t\t\treturn;\n\t\t}\n\t\tdestroyDestination(this.stream);\n\t}\n\n\tpublic async [Symbol.asyncDispose](): Promise<void> {\n\t\tif (this.disposed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.disposed = true;\n\t\tif (!this.retired) {\n\t\t\tconst dest = this.stream as EndableStream | undefined;\n\t\t\tif (dest != null && typeof dest.end === \"function\") {\n\t\t\t\t// pino.transport() is a ThreadStream: pino.flush() → Atomics.waitAsync can\n\t\t\t\t// hang forever after concurrent writes. end() flushSyncs then signals\n\t\t\t\t// finish/close (it does not accept a Node Writable callback).\n\t\t\t\tawait endDestination(dest);\n\t\t\t} else if (this._pino) {\n\t\t\t\tawait new Promise<void>((resolve, reject) => {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis._pino.flush((err?: Error | null) => {\n\t\t\t\t\t\t\tif (err != null) {\n\t\t\t\t\t\t\t\treject(err);\n\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tresolve();\n\t\t\t\t\t\t});\n\t\t\t\t\t} catch (err) {\n\t\t\t\t\t\treject(err instanceof Error ? err : new Error(String(err)));\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\t// Mark dead after graceful end (or immediately if already force-retired).\n\t\tthis.retire();\n\t}\n}\n\nfunction destroyDestination(stream: pino.DestinationStream | undefined): void {\n\tconst destroyable = stream as EndableStream | undefined;\n\tif (typeof destroyable?.destroy === \"function\") {\n\t\ttry {\n\t\t\tdestroyable.destroy();\n\t\t} catch {\n\t\t\t// already dead\n\t\t}\n\t}\n}\n\n/**\n * Drain a pino destination.\n *\n * Node `Writable.end(cb)` invokes `cb`. `pino.transport()` returns a\n * ThreadStream whose `end()` takes no callback and signals via `finish`/`close`\n * instead — waiting only on `end(cb)` hangs forever and blocks Flux HMR.\n */\nfunction endDestination(stream: EndableStream): Promise<void> {\n\tif (typeof stream.end !== \"function\") {\n\t\treturn Promise.resolve();\n\t}\n\tif (stream.destroyed || stream.closed || stream.writableFinished) {\n\t\treturn Promise.resolve();\n\t}\n\n\treturn new Promise<void>((resolve, reject) => {\n\t\tlet settled = false;\n\t\tconst settle = (err?: Error | null) => {\n\t\t\tif (settled) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tsettled = true;\n\t\t\tstream.off?.(\"finish\", onFinish);\n\t\t\tstream.off?.(\"close\", onClose);\n\t\t\tstream.off?.(\"error\", onError);\n\t\t\tif (err != null) {\n\t\t\t\treject(err);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tresolve();\n\t\t};\n\n\t\tconst onFinish = () => settle();\n\t\tconst onClose = () => settle();\n\t\tconst onError = (err: Error) => {\n\t\t\t// ThreadStream may emit error then close during teardown; closed = done.\n\t\t\tif (stream.destroyed || stream.closed) {\n\t\t\t\tsettle();\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tsettle(err);\n\t\t};\n\n\t\tstream.once?.(\"finish\", onFinish);\n\t\tstream.once?.(\"close\", onClose);\n\t\tstream.once?.(\"error\", onError);\n\n\t\ttry {\n\t\t\tstream.end((err?: Error | null) => settle(err));\n\t\t} catch (err) {\n\t\t\tsettle(err instanceof Error ? err : new Error(String(err)));\n\t\t\treturn;\n\t\t}\n\n\t\t// ThreadStream.end() is a no-op when already destroyed (no events).\n\t\tif (stream.destroyed || stream.closed || stream.writableFinished) {\n\t\t\tsettle();\n\t\t}\n\t});\n}\n\nfunction logMethod(this: pino.Logger, args: Parameters<LogFn>, method: LogFn) {\n\tlet message = args.at(0);\n\tconst data = args.at(1);\n\n\tif (message instanceof Error) {\n\t\tmethod.call(this, { err: message }, formatError(message));\n\t\treturn;\n\t}\n\n\tif (data instanceof Error) {\n\t\tmessage = { msg: message, ...{ error: data } };\n\t} else if (typeof data === \"object\") {\n\t\tmessage = { msg: message, ...data };\n\t} else {\n\t\tmessage = { msg: message, data };\n\t}\n\n\tmethod.call(this, message);\n}\n\nfunction pinoMix<T extends string = never, CustomOnly extends true | false = false>(\n\tlogger: pino.Logger,\n): Logger<T, CustomOnly> {\n\treturn Object.assign<pino.Logger, BaseLogger>(logger, {\n\t\tget currentLevel() {\n\t\t\treturn logger.level;\n\t\t},\n\t\tget logLevels() {\n\t\t\treturn logger.levels.values;\n\t\t},\n\t}) as Logger<T, CustomOnly>;\n}\n"],"names":["PinoAdapter","LogAdapter","_pino","options","stream","disposed","retired","configure","scribeOptions","logLevel","redactions","customLevels","getLogLevels","pinoOptions","level","hooks","logMethod","serializers","error","pino","stdSerializers","err","redact","getLogger","name","logger","pinoMix","child","flush","cb","retire","guarded","destroyDestination","Symbol","asyncDispose","dest","end","endDestination","Promise","resolve","reject","Error","String","destroyable","destroy","destroyed","closed","writableFinished","settled","settle","off","onFinish","onClose","onError","once","args","method","message","at","data","call","formatError","msg","Object","assign","currentLevel","logLevels","levels","values"],"mappings":"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"}

package/es6/src/pino.adapater.js

@@ -61,17 +61,28 @@ export class PinoAdapter extends LogAdapter {
             return;
         }
         this.disposed = true;
-        if (this._pino && !this.retired) {
-            await new Promise((resolve)=>{
-                try {
-                    this._pino.flush(()=>resolve());
-                } catch  {
-                    resolve();
-                }
-            });
-        }
         if (!this.retired) {
-            await endDestination(this.stream);
+            const dest = this.stream;
+            if (dest != null && typeof dest.end === "function") {
+                // pino.transport() is a ThreadStream: pino.flush() → Atomics.waitAsync can
+                // hang forever after concurrent writes. end() flushSyncs then signals
+                // finish/close (it does not accept a Node Writable callback).
+                await endDestination(dest);
+            } else if (this._pino) {
+                await new Promise((resolve, reject)=>{
+                    try {
+                        this._pino.flush((err)=>{
+                            if (err != null) {
+                                reject(err);
+                                return;
+                            }
+                            resolve();
+                        });
+                    } catch (err) {
+                        reject(err instanceof Error ? err : new Error(String(err)));
+                    }
+                });
+            }
         }
         // Mark dead after graceful end (or immediately if already force-retired).
         this.retire();
@@ -87,16 +98,57 @@ function destroyDestination(stream) {
         }
     }
 }
-function endDestination(stream) {
-    const endable = stream;
-    if (typeof endable?.end !== "function") {
+/**
+ * Drain a pino destination.
+ *
+ * Node `Writable.end(cb)` invokes `cb`. `pino.transport()` returns a
+ * ThreadStream whose `end()` takes no callback and signals via `finish`/`close`
+ * instead — waiting only on `end(cb)` hangs forever and blocks Flux HMR.
+ */ function endDestination(stream) {
+    if (typeof stream.end !== "function") {
         return Promise.resolve();
     }
-    return new Promise((resolve)=>{
-        try {
-            endable.end(()=>resolve());
-        } catch  {
+    if (stream.destroyed || stream.closed || stream.writableFinished) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        const settle = (err)=>{
+            if (settled) {
+                return;
+            }
+            settled = true;
+            stream.off?.("finish", onFinish);
+            stream.off?.("close", onClose);
+            stream.off?.("error", onError);
+            if (err != null) {
+                reject(err);
+                return;
+            }
             resolve();
+        };
+        const onFinish = ()=>settle();
+        const onClose = ()=>settle();
+        const onError = (err)=>{
+            // ThreadStream may emit error then close during teardown; closed = done.
+            if (stream.destroyed || stream.closed) {
+                settle();
+                return;
+            }
+            settle(err);
+        };
+        stream.once?.("finish", onFinish);
+        stream.once?.("close", onClose);
+        stream.once?.("error", onError);
+        try {
+            stream.end((err)=>settle(err));
+        } catch (err) {
+            settle(err instanceof Error ? err : new Error(String(err)));
+            return;
+        }
+        // ThreadStream.end() is a no-op when already destroyed (no events).
+        if (stream.destroyed || stream.closed || stream.writableFinished) {
+            settle();
         }
     });
 }
@@ -140,4 +192,4 @@ function pinoMix(logger) {
     });
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe-pino/src/pino.adapater.ts"],"sourcesContent":["import {\n\ttype BaseLogger,\n\tformatError,\n\tLogAdapter,\n\ttype Logger,\n\ttype ScribeOptions,\n} from \"@decohere/scribe\";\nimport pino, { type LogFn } from \"pino\";\n\nimport type { GuardedTransport } from \"./pino.transport-guard.js\";\n\nexport type PinoAdapaterOptions = {\n\toptions?: pino.LoggerOptions;\n\tstream?: pino.DestinationStream;\n};\n\ntype EndableStream = {\n\tend?: (cb?: (err?: Error | null) => void) => void;\n\tdestroy?: (error?: Error) => void;\n};\n\nexport class PinoAdapter extends LogAdapter {\n\tprivate _pino: pino.Logger;\n\tprivate readonly options: pino.LoggerOptions;\n\tprivate readonly stream: pino.DestinationStream | undefined;\n\tprivate disposed = false;\n\tprivate retired = false;\n\n\tpublic constructor(options: pino.LoggerOptions, stream?: pino.DestinationStream) {\n\t\tsuper();\n\t\tthis.options = options;\n\t\tthis.stream = stream;\n\t}\n\n\tpublic configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tscribeOptions: ScribeOptions<T, CustomOnly>,\n\t) {\n\t\tconst { logLevel, redactions } = scribeOptions;\n\t\tconst customLevels = this.getLogLevels(scribeOptions);\n\n\t\tconst pinoOptions: pino.LoggerOptions = {\n\t\t\tcustomLevels,\n\t\t\tlevel: logLevel,\n\t\t\thooks: { logMethod },\n\t\t\tserializers: {\n\t\t\t\terror: pino.stdSerializers.err,\n\t\t\t},\n\t\t\tredact: redactions,\n\t\t\t...this.options,\n\t\t};\n\t\tthis._pino = pino(pinoOptions, this.stream);\n\t}\n\n\tpublic getLogger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname: string,\n\t): Logger<T, CustomOnly> {\n\t\tconst logger = pinoMix<T, CustomOnly>(this._pino.child({ name }));\n\t\treturn logger;\n\t}\n\n\tpublic flush(cb?: () => void): void {\n\t\tif (this.retired || !this._pino) {\n\t\t\tcb?.();\n\t\t\treturn;\n\t\t}\n\t\tthis._pino.flush(cb);\n\t}\n\n\t/**\n\t * Immediately stop accepting writes into the destination (ThreadStream).\n\t * Does not wait for flush — use `stop()` for async drain after retire.\n\t */\n\tpublic retire(): void {\n\t\tif (this.retired) {\n\t\t\treturn;\n\t\t}\n\t\tthis.retired = true;\n\t\tconst guarded = this.stream as GuardedTransport | undefined;\n\t\tif (typeof guarded?.retire === \"function\") {\n\t\t\tguarded.retire(\"adapter retired\");\n\t\t\treturn;\n\t\t}\n\t\tdestroyDestination(this.stream);\n\t}\n\n\tpublic async [Symbol.asyncDispose](): Promise<void> {\n\t\tif (this.disposed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.disposed = true;\n\t\tif (this._pino && !this.retired) {\n\t\t\tawait new Promise<void>((resolve) => {\n\t\t\t\ttry {\n\t\t\t\t\tthis._pino.flush(() => resolve());\n\t\t\t\t} catch {\n\t\t\t\t\tresolve();\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\tif (!this.retired) {\n\t\t\tawait endDestination(this.stream);\n\t\t}\n\t\t// Mark dead after graceful end (or immediately if already force-retired).\n\t\tthis.retire();\n\t}\n}\n\nfunction destroyDestination(stream: pino.DestinationStream | undefined): void {\n\tconst destroyable = stream as EndableStream | undefined;\n\tif (typeof destroyable?.destroy === \"function\") {\n\t\ttry {\n\t\t\tdestroyable.destroy();\n\t\t} catch {\n\t\t\t// already dead\n\t\t}\n\t}\n}\n\nfunction endDestination(stream: pino.DestinationStream | undefined): Promise<void> {\n\tconst endable = stream as EndableStream | undefined;\n\tif (typeof endable?.end !== \"function\") {\n\t\treturn Promise.resolve();\n\t}\n\treturn new Promise<void>((resolve) => {\n\t\ttry {\n\t\t\tendable.end(() => resolve());\n\t\t} catch {\n\t\t\tresolve();\n\t\t}\n\t});\n}\n\nfunction logMethod(this: pino.Logger, args: Parameters<LogFn>, method: LogFn) {\n\tlet message = args.at(0);\n\tconst data = args.at(1);\n\n\tif (message instanceof Error) {\n\t\tmethod.call(this, { err: message }, formatError(message));\n\t\treturn;\n\t}\n\n\tif (data instanceof Error) {\n\t\tmessage = { msg: message, ...{ error: data } };\n\t} else if (typeof data === \"object\") {\n\t\tmessage = { msg: message, ...data };\n\t} else {\n\t\tmessage = { msg: message, data };\n\t}\n\n\tmethod.call(this, message);\n}\n\nfunction pinoMix<T extends string = never, CustomOnly extends true | false = false>(\n\tlogger: pino.Logger,\n): Logger<T, CustomOnly> {\n\treturn Object.assign<pino.Logger, BaseLogger>(logger, {\n\t\tget currentLevel() {\n\t\t\treturn logger.level;\n\t\t},\n\t\tget logLevels() {\n\t\t\treturn logger.levels.values;\n\t\t},\n\t}) as Logger<T, CustomOnly>;\n}\n"],"names":["formatError","LogAdapter","pino","PinoAdapter","_pino","options","stream","disposed","retired","configure","scribeOptions","logLevel","redactions","customLevels","getLogLevels","pinoOptions","level","hooks","logMethod","serializers","error","stdSerializers","err","redact","getLogger","name","logger","pinoMix","child","flush","cb","retire","guarded","destroyDestination","Symbol","asyncDispose","Promise","resolve","endDestination","destroyable","destroy","endable","end","args","method","message","at","data","Error","call","msg","Object","assign","currentLevel","logLevels","levels","values"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe-pino/src/pino.adapater.ts"],"sourcesContent":["import {\n\ttype BaseLogger,\n\tformatError,\n\tLogAdapter,\n\ttype Logger,\n\ttype ScribeOptions,\n} from \"@decohere/scribe\";\nimport pino, { type LogFn } from \"pino\";\n\nimport type { GuardedTransport } from \"./pino.transport-guard.js\";\n\nexport type PinoAdapaterOptions = {\n\toptions?: pino.LoggerOptions;\n\tstream?: pino.DestinationStream;\n};\n\ntype EndableStream = {\n\tend?: (cb?: (err?: Error | null) => void) => void;\n\tdestroy?: (error?: Error) => void;\n\tdestroyed?: boolean;\n\tclosed?: boolean;\n\twritableFinished?: boolean;\n\tonce?: (\n\t\tevent: \"finish\" | \"close\" | \"error\",\n\t\tlistener: (...args: never[]) => void,\n\t) => unknown;\n\toff?: (event: \"finish\" | \"close\" | \"error\", listener: (...args: never[]) => void) => unknown;\n};\n\nexport class PinoAdapter extends LogAdapter {\n\tprivate _pino: pino.Logger;\n\tprivate readonly options: pino.LoggerOptions;\n\tprivate readonly stream: pino.DestinationStream | undefined;\n\tprivate disposed = false;\n\tprivate retired = false;\n\n\tpublic constructor(options: pino.LoggerOptions, stream?: pino.DestinationStream) {\n\t\tsuper();\n\t\tthis.options = options;\n\t\tthis.stream = stream;\n\t}\n\n\tpublic configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tscribeOptions: ScribeOptions<T, CustomOnly>,\n\t) {\n\t\tconst { logLevel, redactions } = scribeOptions;\n\t\tconst customLevels = this.getLogLevels(scribeOptions);\n\n\t\tconst pinoOptions: pino.LoggerOptions = {\n\t\t\tcustomLevels,\n\t\t\tlevel: logLevel,\n\t\t\thooks: { logMethod },\n\t\t\tserializers: {\n\t\t\t\terror: pino.stdSerializers.err,\n\t\t\t},\n\t\t\tredact: redactions,\n\t\t\t...this.options,\n\t\t};\n\t\tthis._pino = pino(pinoOptions, this.stream);\n\t}\n\n\tpublic getLogger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname: string,\n\t): Logger<T, CustomOnly> {\n\t\tconst logger = pinoMix<T, CustomOnly>(this._pino.child({ name }));\n\t\treturn logger;\n\t}\n\n\tpublic flush(cb?: () => void): void {\n\t\tif (this.retired || !this._pino) {\n\t\t\tcb?.();\n\t\t\treturn;\n\t\t}\n\t\tthis._pino.flush(cb);\n\t}\n\n\t/**\n\t * Immediately stop accepting writes into the destination (ThreadStream).\n\t * Does not wait for flush — use `stop()` for async drain after retire.\n\t */\n\tpublic retire(): void {\n\t\tif (this.retired) {\n\t\t\treturn;\n\t\t}\n\t\tthis.retired = true;\n\t\tconst guarded = this.stream as GuardedTransport | undefined;\n\t\tif (typeof guarded?.retire === \"function\") {\n\t\t\tguarded.retire(\"adapter retired\");\n\t\t\treturn;\n\t\t}\n\t\tdestroyDestination(this.stream);\n\t}\n\n\tpublic async [Symbol.asyncDispose](): Promise<void> {\n\t\tif (this.disposed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.disposed = true;\n\t\tif (!this.retired) {\n\t\t\tconst dest = this.stream as EndableStream | undefined;\n\t\t\tif (dest != null && typeof dest.end === \"function\") {\n\t\t\t\t// pino.transport() is a ThreadStream: pino.flush() → Atomics.waitAsync can\n\t\t\t\t// hang forever after concurrent writes. end() flushSyncs then signals\n\t\t\t\t// finish/close (it does not accept a Node Writable callback).\n\t\t\t\tawait endDestination(dest);\n\t\t\t} else if (this._pino) {\n\t\t\t\tawait new Promise<void>((resolve, reject) => {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis._pino.flush((err?: Error | null) => {\n\t\t\t\t\t\t\tif (err != null) {\n\t\t\t\t\t\t\t\treject(err);\n\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tresolve();\n\t\t\t\t\t\t});\n\t\t\t\t\t} catch (err) {\n\t\t\t\t\t\treject(err instanceof Error ? err : new Error(String(err)));\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\t// Mark dead after graceful end (or immediately if already force-retired).\n\t\tthis.retire();\n\t}\n}\n\nfunction destroyDestination(stream: pino.DestinationStream | undefined): void {\n\tconst destroyable = stream as EndableStream | undefined;\n\tif (typeof destroyable?.destroy === \"function\") {\n\t\ttry {\n\t\t\tdestroyable.destroy();\n\t\t} catch {\n\t\t\t// already dead\n\t\t}\n\t}\n}\n\n/**\n * Drain a pino destination.\n *\n * Node `Writable.end(cb)` invokes `cb`. `pino.transport()` returns a\n * ThreadStream whose `end()` takes no callback and signals via `finish`/`close`\n * instead — waiting only on `end(cb)` hangs forever and blocks Flux HMR.\n */\nfunction endDestination(stream: EndableStream): Promise<void> {\n\tif (typeof stream.end !== \"function\") {\n\t\treturn Promise.resolve();\n\t}\n\tif (stream.destroyed || stream.closed || stream.writableFinished) {\n\t\treturn Promise.resolve();\n\t}\n\n\treturn new Promise<void>((resolve, reject) => {\n\t\tlet settled = false;\n\t\tconst settle = (err?: Error | null) => {\n\t\t\tif (settled) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tsettled = true;\n\t\t\tstream.off?.(\"finish\", onFinish);\n\t\t\tstream.off?.(\"close\", onClose);\n\t\t\tstream.off?.(\"error\", onError);\n\t\t\tif (err != null) {\n\t\t\t\treject(err);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tresolve();\n\t\t};\n\n\t\tconst onFinish = () => settle();\n\t\tconst onClose = () => settle();\n\t\tconst onError = (err: Error) => {\n\t\t\t// ThreadStream may emit error then close during teardown; closed = done.\n\t\t\tif (stream.destroyed || stream.closed) {\n\t\t\t\tsettle();\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tsettle(err);\n\t\t};\n\n\t\tstream.once?.(\"finish\", onFinish);\n\t\tstream.once?.(\"close\", onClose);\n\t\tstream.once?.(\"error\", onError);\n\n\t\ttry {\n\t\t\tstream.end((err?: Error | null) => settle(err));\n\t\t} catch (err) {\n\t\t\tsettle(err instanceof Error ? err : new Error(String(err)));\n\t\t\treturn;\n\t\t}\n\n\t\t// ThreadStream.end() is a no-op when already destroyed (no events).\n\t\tif (stream.destroyed || stream.closed || stream.writableFinished) {\n\t\t\tsettle();\n\t\t}\n\t});\n}\n\nfunction logMethod(this: pino.Logger, args: Parameters<LogFn>, method: LogFn) {\n\tlet message = args.at(0);\n\tconst data = args.at(1);\n\n\tif (message instanceof Error) {\n\t\tmethod.call(this, { err: message }, formatError(message));\n\t\treturn;\n\t}\n\n\tif (data instanceof Error) {\n\t\tmessage = { msg: message, ...{ error: data } };\n\t} else if (typeof data === \"object\") {\n\t\tmessage = { msg: message, ...data };\n\t} else {\n\t\tmessage = { msg: message, data };\n\t}\n\n\tmethod.call(this, message);\n}\n\nfunction pinoMix<T extends string = never, CustomOnly extends true | false = false>(\n\tlogger: pino.Logger,\n): Logger<T, CustomOnly> {\n\treturn Object.assign<pino.Logger, BaseLogger>(logger, {\n\t\tget currentLevel() {\n\t\t\treturn logger.level;\n\t\t},\n\t\tget logLevels() {\n\t\t\treturn logger.levels.values;\n\t\t},\n\t}) as Logger<T, CustomOnly>;\n}\n"],"names":["formatError","LogAdapter","pino","PinoAdapter","_pino","options","stream","disposed","retired","configure","scribeOptions","logLevel","redactions","customLevels","getLogLevels","pinoOptions","level","hooks","logMethod","serializers","error","stdSerializers","err","redact","getLogger","name","logger","pinoMix","child","flush","cb","retire","guarded","destroyDestination","Symbol","asyncDispose","dest","end","endDestination","Promise","resolve","reject","Error","String","destroyable","destroy","destroyed","closed","writableFinished","settled","settle","off","onFinish","onClose","onError","once","args","method","message","at","data","call","msg","Object","assign","currentLevel","logLevels","levels","values"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/scribe-pino",
-  "version": "0.0.1-dev.70",
+  "version": "0.0.1-dev.72",
   "description": "Pino adapter for @decohere/scribe",
   "keywords": [
     "typescript",
@@ -23,8 +23,8 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/nexus": "0.0.1-dev.70",
-    "@decohere/scribe": "0.0.1-dev.70",
+    "@decohere/nexus": "0.0.1-dev.72",
+    "@decohere/scribe": "0.0.1-dev.72",
     "pino": "^10.3.0"
   },
   "devDependencies": {},