@decohere/scribe 0.0.1-dev.77 → 0.0.1-dev.79

package/commonjs/src/logger.factory.js

@@ -14,20 +14,27 @@ const _errors = require("./errors.js");
 const _types = require("./types.js");
 class scribe {
     loggerProvider;
+    /** True after `configure({ adapter })` — the constructor’s ConsoleAdapter is only a fallback. */ adapterConfigured = false;
+    defaultAdapterWarned = false;
     static instance = new scribe();
     static logger(name, customLevels) {
-        return scribe.instance.getLogger(name, customLevels);
+        // Apply custom levels once against the active adapter; the live handle
+        // re-resolves the underlying logger on each use (CU-869egxmg2).
+        if (customLevels) {
+            scribe.instance.getLogger(name, customLevels);
+        }
+        return scribe.createLiveLogger(name);
     }
     static configure(configOptions) {
         const previous = scribe.instance;
         // Sync: stop writes into the old ThreadStream before a new worker starts.
         previous.retire();
         scribe.instance = new scribe();
-        const factory = scribe.instance.configure(configOptions);
+        scribe.instance.configure(configOptions);
         // Async drain of the retired adapter (flush / end). Flux/App.stop may
         // have already done this; reconfigure without stop still needs it.
         void previous.stop();
-        return factory;
+        return (name)=>scribe.logger(name);
     }
     static flush(cb) {
         scribe.instance.loggerProvider.flush(cb);
@@ -38,6 +45,23 @@ class scribe {
     /** Drain the active adapter and release workers / destinations. */ static async stop() {
         await scribe.instance.stop();
     }
+    /**
+	 * Module-level `const log = scribe.logger(...)` must follow a later
+	 * `scribe.configure()` (CLI / Flux / HotReloadServer). Forward every use to
+	 * the active adapter logger for `name`.
+	 */ static createLiveLogger(name) {
+        return new Proxy({}, {
+            get (_target, prop) {
+                const underlying = scribe.instance.getLogger(name);
+                const value = Reflect.get(underlying, prop, underlying);
+                return typeof value === "function" ? value.bind(underlying) : value;
+            },
+            has (_target, prop) {
+                const underlying = scribe.instance.getLogger(name);
+                return Reflect.has(underlying, prop);
+            }
+        });
+    }
     constructor(){
         // Initialize with default console adapter
         this.loggerProvider = new _consoleadapter.ConsoleAdapter();
@@ -51,12 +75,13 @@ class scribe {
             previous.retire();
         }
         this.loggerProvider = adapter;
+        this.adapterConfigured = true;
         const defaultsAndOptions = this.mergeDefaults(options);
         adapter.configure(defaultsAndOptions);
         if (previous !== adapter) {
             void previous.stop();
         }
-        return (name)=>adapter.getLogger(name);
+        return (name)=>scribe.logger(name);
     }
     retire() {
         this.loggerProvider.retire();
@@ -68,6 +93,7 @@ class scribe {
         await this.stop();
     }
     getLogger(name, customLevels) {
+        this.warnIfDefaultAdapter();
         // If custom levels are provided, we need to reconfigure the adapter
         if (customLevels) {
             const currentOptions = this.mergeDefaults({
@@ -79,6 +105,13 @@ class scribe {
         this.supportsLevels(customLevels, logger);
         return logger;
     }
+    warnIfDefaultAdapter() {
+        if (this.adapterConfigured || this.defaultAdapterWarned) {
+            return;
+        }
+        this.defaultAdapterWarned = true;
+        process.stderr.write("[scribe] No logger adapter configured; using the default ConsoleAdapter. " + "Configure an adapter at your composition root (for production, prefer " + "@decohere/scribe-pino → JSON on stdout). See " + "https://github.com/typesmiths/decohere/blob/main/projects/scribe/README.md\n");
+    }
     supportsLevels(customLevels, logger) {
         if (!customLevels) {
             return;
@@ -93,12 +126,14 @@ class scribe {
     }
     mergeDefaults(options) {
         const logLevel = (0, _env.resolveLogLevel)(options?.logLevel) ?? _types.DefaultLogLevel;
+        // Resolved logLevel must win over options spread (invalid explicit values
+        // would otherwise stick — CU-869emqjq8).
         return {
-            logLevel,
             redactions: _types.DefaultRedactions,
-            ...options
+            ...options,
+            logLevel
         };
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe/src/logger.factory.ts"],"sourcesContent":["import { ConsoleAdapter } from \"./console.adapter.js\";\nimport { resolveLogLevel } from \"./env.js\";\nimport { LoggingConfigurationError } from \"./errors.js\";\nimport type { LoggerAdapter } from \"./logger.adapter.js\";\nimport type { Logger } from \"./logger.type.js\";\nimport { DefaultLogLevel, DefaultRedactions, type ScribeOptions } from \"./types.js\";\n\ntype LoggerFactoryOptions<\n\tT extends string = never,\n\tCustomOnly extends true | false = false,\n> = {\n\toptions?: ScribeOptions<T, CustomOnly>;\n\tadapter: LoggerAdapter;\n};\n\nexport class scribe implements AsyncDisposable {\n\tprivate loggerProvider: LoggerAdapter;\n\tprivate static instance: scribe = new scribe();\n\n\tpublic static logger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname?: string,\n\t\tcustomLevels?: {\n\t\t\t[level in T]: number;\n\t\t},\n\t): Logger<T, CustomOnly> {\n\t\treturn scribe.instance.getLogger<T, CustomOnly>(name, customLevels) as Logger<\n\t\t\tT,\n\t\t\tCustomOnly\n\t\t>;\n\t}\n\n\tpublic static configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tconfigOptions: LoggerFactoryOptions<T, CustomOnly>,\n\t) {\n\t\tconst previous = scribe.instance;\n\t\t// Sync: stop writes into the old ThreadStream before a new worker starts.\n\t\tprevious.retire();\n\t\tscribe.instance = new scribe();\n\t\tconst factory = scribe.instance.configure<T, CustomOnly>(configOptions);\n\t\t// Async drain of the retired adapter (flush / end). Flux/App.stop may\n\t\t// have already done this; reconfigure without stop still needs it.\n\t\tvoid previous.stop();\n\t\treturn factory;\n\t}\n\n\tpublic static flush(cb?: () => void): void {\n\t\tscribe.instance.loggerProvider.flush(cb);\n\t}\n\n\t/** Synchronously stop accepting writes on the active adapter. */\n\tpublic static retire(): void {\n\t\tscribe.instance.retire();\n\t}\n\n\t/** Drain the active adapter and release workers / destinations. */\n\tpublic static async stop(): Promise<void> {\n\t\tawait scribe.instance.stop();\n\t}\n\n\tpublic constructor() {\n\t\t// Initialize with default console adapter\n\t\tthis.loggerProvider = new ConsoleAdapter();\n\t\tconst defaultOptions = this.mergeDefaults();\n\t\tthis.loggerProvider.configure(defaultOptions);\n\t}\n\n\tpublic configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tconfigOptions: LoggerFactoryOptions<T, CustomOnly>,\n\t): (name?: string) => Logger<T, CustomOnly> {\n\t\tconst { adapter, options } = configOptions;\n\t\tconst previous = this.loggerProvider;\n\t\tif (previous !== adapter) {\n\t\t\tprevious.retire();\n\t\t}\n\t\tthis.loggerProvider = adapter;\n\t\tconst defaultsAndOptions = this.mergeDefaults<T, CustomOnly>(options);\n\t\tadapter.configure(defaultsAndOptions);\n\t\tif (previous !== adapter) {\n\t\t\tvoid previous.stop();\n\t\t}\n\t\treturn (name?: string) => adapter.getLogger(name) as Logger<T, CustomOnly>;\n\t}\n\n\tpublic retire(): void {\n\t\tthis.loggerProvider.retire();\n\t}\n\n\tpublic async stop(): Promise<void> {\n\t\tawait this.loggerProvider.stop();\n\t}\n\n\tpublic async [Symbol.asyncDispose](): Promise<void> {\n\t\tawait this.stop();\n\t}\n\n\tpublic getLogger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname?: string,\n\t\tcustomLevels?: {\n\t\t\t[level in T]: number;\n\t\t},\n\t): Logger<T, CustomOnly> {\n\t\t// If custom levels are provided, we need to reconfigure the adapter\n\t\tif (customLevels) {\n\t\t\tconst currentOptions = this.mergeDefaults({ customLevels });\n\t\t\tthis.loggerProvider.configure(currentOptions);\n\t\t}\n\n\t\tconst logger = this.loggerProvider.getLogger(name) as Logger<T, CustomOnly>;\n\t\tthis.supportsLevels(customLevels, logger);\n\t\treturn logger;\n\t}\n\n\tprivate supportsLevels<T extends string = never, CustomOnly extends true = undefined>(\n\t\tcustomLevels: {\n\t\t\t[level in T]: number;\n\t\t},\n\t\tlogger: Logger<T, CustomOnly>,\n\t) {\n\t\tif (!customLevels) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst missingLevel = Object.entries(customLevels).find(\n\t\t\t(key) => !logger.logLevels[key.at(0).toString()],\n\t\t);\n\n\t\tif (missingLevel != null) {\n\t\t\tthrow new LoggingConfigurationError(\n\t\t\t\t`Current logger was not configured for custom level ${missingLevel}, valid levels are: ${JSON.stringify(logger.logLevels)}`,\n\t\t\t);\n\t\t}\n\t\treturn { missingLevel };\n\t}\n\n\tprivate mergeDefaults<T extends string = never, CustomOnly extends true | false = false>(\n\t\toptions?: ScribeOptions<T, CustomOnly>,\n\t): ScribeOptions<T, CustomOnly> {\n\t\tconst logLevel = resolveLogLevel(options?.logLevel) ?? DefaultLogLevel;\n\t\treturn { logLevel, redactions: DefaultRedactions, ...options };\n\t}\n}\n"],"names":["scribe","loggerProvider","instance","logger","name","customLevels","getLogger","configure","configOptions","previous","retire","factory","stop","flush","cb","ConsoleAdapter","defaultOptions","mergeDefaults","adapter","options","defaultsAndOptions","Symbol","asyncDispose","currentOptions","supportsLevels","missingLevel","Object","entries","find","key","logLevels","at","toString","LoggingConfigurationError","JSON","stringify","logLevel","resolveLogLevel","DefaultLogLevel","redactions","DefaultRedactions"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe/src/logger.factory.ts"],"sourcesContent":["import { ConsoleAdapter } from \"./console.adapter.js\";\nimport { resolveLogLevel } from \"./env.js\";\nimport { LoggingConfigurationError } from \"./errors.js\";\nimport type { LoggerAdapter } from \"./logger.adapter.js\";\nimport type { Logger } from \"./logger.type.js\";\nimport { DefaultLogLevel, DefaultRedactions, type ScribeOptions } from \"./types.js\";\n\ntype LoggerFactoryOptions<\n\tT extends string = never,\n\tCustomOnly extends true | false = false,\n> = {\n\toptions?: ScribeOptions<T, CustomOnly>;\n\tadapter: LoggerAdapter;\n};\n\nexport class scribe implements AsyncDisposable {\n\tprivate loggerProvider: LoggerAdapter;\n\t/** True after `configure({ adapter })` — the constructor’s ConsoleAdapter is only a fallback. */\n\tprivate adapterConfigured = false;\n\tprivate defaultAdapterWarned = false;\n\tprivate static instance: scribe = new scribe();\n\n\tpublic static logger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname?: string,\n\t\tcustomLevels?: {\n\t\t\t[level in T]: number;\n\t\t},\n\t): Logger<T, CustomOnly> {\n\t\t// Apply custom levels once against the active adapter; the live handle\n\t\t// re-resolves the underlying logger on each use (CU-869egxmg2).\n\t\tif (customLevels) {\n\t\t\tscribe.instance.getLogger<T, CustomOnly>(name, customLevels);\n\t\t}\n\t\treturn scribe.createLiveLogger<T, CustomOnly>(name);\n\t}\n\n\tpublic static configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tconfigOptions: LoggerFactoryOptions<T, CustomOnly>,\n\t) {\n\t\tconst previous = scribe.instance;\n\t\t// Sync: stop writes into the old ThreadStream before a new worker starts.\n\t\tprevious.retire();\n\t\tscribe.instance = new scribe();\n\t\tscribe.instance.configure<T, CustomOnly>(configOptions);\n\t\t// Async drain of the retired adapter (flush / end). Flux/App.stop may\n\t\t// have already done this; reconfigure without stop still needs it.\n\t\tvoid previous.stop();\n\t\treturn (name?: string) => scribe.logger<T, CustomOnly>(name);\n\t}\n\n\tpublic static flush(cb?: () => void): void {\n\t\tscribe.instance.loggerProvider.flush(cb);\n\t}\n\n\t/** Synchronously stop accepting writes on the active adapter. */\n\tpublic static retire(): void {\n\t\tscribe.instance.retire();\n\t}\n\n\t/** Drain the active adapter and release workers / destinations. */\n\tpublic static async stop(): Promise<void> {\n\t\tawait scribe.instance.stop();\n\t}\n\n\t/**\n\t * Module-level `const log = scribe.logger(...)` must follow a later\n\t * `scribe.configure()` (CLI / Flux / HotReloadServer). Forward every use to\n\t * the active adapter logger for `name`.\n\t */\n\tprivate static createLiveLogger<\n\t\tT extends string = never,\n\t\tCustomOnly extends true | false = false,\n\t>(name?: string): Logger<T, CustomOnly> {\n\t\treturn new Proxy({} as Logger<T, CustomOnly>, {\n\t\t\tget(_target, prop) {\n\t\t\t\tconst underlying = scribe.instance.getLogger<T, CustomOnly>(name) as object;\n\t\t\t\tconst value = Reflect.get(underlying, prop, underlying);\n\t\t\t\treturn typeof value === \"function\"\n\t\t\t\t\t? (value as (...args: never[]) => unknown).bind(underlying)\n\t\t\t\t\t: value;\n\t\t\t},\n\t\t\thas(_target, prop) {\n\t\t\t\tconst underlying = scribe.instance.getLogger<T, CustomOnly>(name) as object;\n\t\t\t\treturn Reflect.has(underlying, prop);\n\t\t\t},\n\t\t});\n\t}\n\n\tpublic constructor() {\n\t\t// Initialize with default console adapter\n\t\tthis.loggerProvider = new ConsoleAdapter();\n\t\tconst defaultOptions = this.mergeDefaults();\n\t\tthis.loggerProvider.configure(defaultOptions);\n\t}\n\n\tpublic configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tconfigOptions: LoggerFactoryOptions<T, CustomOnly>,\n\t): (name?: string) => Logger<T, CustomOnly> {\n\t\tconst { adapter, options } = configOptions;\n\t\tconst previous = this.loggerProvider;\n\t\tif (previous !== adapter) {\n\t\t\tprevious.retire();\n\t\t}\n\t\tthis.loggerProvider = adapter;\n\t\tthis.adapterConfigured = true;\n\t\tconst defaultsAndOptions = this.mergeDefaults<T, CustomOnly>(options);\n\t\tadapter.configure(defaultsAndOptions);\n\t\tif (previous !== adapter) {\n\t\t\tvoid previous.stop();\n\t\t}\n\t\treturn (name?: string) => scribe.logger<T, CustomOnly>(name);\n\t}\n\n\tpublic retire(): void {\n\t\tthis.loggerProvider.retire();\n\t}\n\n\tpublic async stop(): Promise<void> {\n\t\tawait this.loggerProvider.stop();\n\t}\n\n\tpublic async [Symbol.asyncDispose](): Promise<void> {\n\t\tawait this.stop();\n\t}\n\n\tpublic getLogger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname?: string,\n\t\tcustomLevels?: {\n\t\t\t[level in T]: number;\n\t\t},\n\t): Logger<T, CustomOnly> {\n\t\tthis.warnIfDefaultAdapter();\n\n\t\t// If custom levels are provided, we need to reconfigure the adapter\n\t\tif (customLevels) {\n\t\t\tconst currentOptions = this.mergeDefaults({ customLevels });\n\t\t\tthis.loggerProvider.configure(currentOptions);\n\t\t}\n\n\t\tconst logger = this.loggerProvider.getLogger(name) as Logger<T, CustomOnly>;\n\t\tthis.supportsLevels(customLevels, logger);\n\t\treturn logger;\n\t}\n\n\tprivate warnIfDefaultAdapter(): void {\n\t\tif (this.adapterConfigured || this.defaultAdapterWarned) {\n\t\t\treturn;\n\t\t}\n\t\tthis.defaultAdapterWarned = true;\n\t\tprocess.stderr.write(\n\t\t\t\"[scribe] No logger adapter configured; using the default ConsoleAdapter. \" +\n\t\t\t\t\"Configure an adapter at your composition root (for production, prefer \" +\n\t\t\t\t\"@decohere/scribe-pino → JSON on stdout). See \" +\n\t\t\t\t\"https://github.com/typesmiths/decohere/blob/main/projects/scribe/README.md\\n\",\n\t\t);\n\t}\n\n\tprivate supportsLevels<T extends string = never, CustomOnly extends true = undefined>(\n\t\tcustomLevels: {\n\t\t\t[level in T]: number;\n\t\t},\n\t\tlogger: Logger<T, CustomOnly>,\n\t) {\n\t\tif (!customLevels) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst missingLevel = Object.entries(customLevels).find(\n\t\t\t(key) => !logger.logLevels[key.at(0).toString()],\n\t\t);\n\n\t\tif (missingLevel != null) {\n\t\t\tthrow new LoggingConfigurationError(\n\t\t\t\t`Current logger was not configured for custom level ${missingLevel}, valid levels are: ${JSON.stringify(logger.logLevels)}`,\n\t\t\t);\n\t\t}\n\t\treturn { missingLevel };\n\t}\n\n\tprivate mergeDefaults<T extends string = never, CustomOnly extends true | false = false>(\n\t\toptions?: ScribeOptions<T, CustomOnly>,\n\t): ScribeOptions<T, CustomOnly> {\n\t\tconst logLevel = resolveLogLevel(options?.logLevel) ?? DefaultLogLevel;\n\t\t// Resolved logLevel must win over options spread (invalid explicit values\n\t\t// would otherwise stick — CU-869emqjq8).\n\t\treturn { redactions: DefaultRedactions, ...options, logLevel };\n\t}\n}\n"],"names":["scribe","loggerProvider","adapterConfigured","defaultAdapterWarned","instance","logger","name","customLevels","getLogger","createLiveLogger","configure","configOptions","previous","retire","stop","flush","cb","Proxy","get","_target","prop","underlying","value","Reflect","bind","has","ConsoleAdapter","defaultOptions","mergeDefaults","adapter","options","defaultsAndOptions","Symbol","asyncDispose","warnIfDefaultAdapter","currentOptions","supportsLevels","process","stderr","write","missingLevel","Object","entries","find","key","logLevels","at","toString","LoggingConfigurationError","JSON","stringify","logLevel","resolveLogLevel","DefaultLogLevel","redactions","DefaultRedactions"],"mappings":"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"}

package/es6/src/logger.factory.js

@@ -4,20 +4,27 @@ import { LoggingConfigurationError } from "./errors.js";
 import { DefaultLogLevel, DefaultRedactions } from "./types.js";
 export class scribe {
     loggerProvider;
+    /** True after `configure({ adapter })` — the constructor’s ConsoleAdapter is only a fallback. */ adapterConfigured = false;
+    defaultAdapterWarned = false;
     static instance = new scribe();
     static logger(name, customLevels) {
-        return scribe.instance.getLogger(name, customLevels);
+        // Apply custom levels once against the active adapter; the live handle
+        // re-resolves the underlying logger on each use (CU-869egxmg2).
+        if (customLevels) {
+            scribe.instance.getLogger(name, customLevels);
+        }
+        return scribe.createLiveLogger(name);
     }
     static configure(configOptions) {
         const previous = scribe.instance;
         // Sync: stop writes into the old ThreadStream before a new worker starts.
         previous.retire();
         scribe.instance = new scribe();
-        const factory = scribe.instance.configure(configOptions);
+        scribe.instance.configure(configOptions);
         // Async drain of the retired adapter (flush / end). Flux/App.stop may
         // have already done this; reconfigure without stop still needs it.
         void previous.stop();
-        return factory;
+        return (name)=>scribe.logger(name);
     }
     static flush(cb) {
         scribe.instance.loggerProvider.flush(cb);
@@ -28,6 +35,23 @@ export class scribe {
     /** Drain the active adapter and release workers / destinations. */ static async stop() {
         await scribe.instance.stop();
     }
+    /**
+	 * Module-level `const log = scribe.logger(...)` must follow a later
+	 * `scribe.configure()` (CLI / Flux / HotReloadServer). Forward every use to
+	 * the active adapter logger for `name`.
+	 */ static createLiveLogger(name) {
+        return new Proxy({}, {
+            get (_target, prop) {
+                const underlying = scribe.instance.getLogger(name);
+                const value = Reflect.get(underlying, prop, underlying);
+                return typeof value === "function" ? value.bind(underlying) : value;
+            },
+            has (_target, prop) {
+                const underlying = scribe.instance.getLogger(name);
+                return Reflect.has(underlying, prop);
+            }
+        });
+    }
     constructor(){
         // Initialize with default console adapter
         this.loggerProvider = new ConsoleAdapter();
@@ -41,12 +65,13 @@ export class scribe {
             previous.retire();
         }
         this.loggerProvider = adapter;
+        this.adapterConfigured = true;
         const defaultsAndOptions = this.mergeDefaults(options);
         adapter.configure(defaultsAndOptions);
         if (previous !== adapter) {
             void previous.stop();
         }
-        return (name)=>adapter.getLogger(name);
+        return (name)=>scribe.logger(name);
     }
     retire() {
         this.loggerProvider.retire();
@@ -58,6 +83,7 @@ export class scribe {
         await this.stop();
     }
     getLogger(name, customLevels) {
+        this.warnIfDefaultAdapter();
         // If custom levels are provided, we need to reconfigure the adapter
         if (customLevels) {
             const currentOptions = this.mergeDefaults({
@@ -69,6 +95,13 @@ export class scribe {
         this.supportsLevels(customLevels, logger);
         return logger;
     }
+    warnIfDefaultAdapter() {
+        if (this.adapterConfigured || this.defaultAdapterWarned) {
+            return;
+        }
+        this.defaultAdapterWarned = true;
+        process.stderr.write("[scribe] No logger adapter configured; using the default ConsoleAdapter. " + "Configure an adapter at your composition root (for production, prefer " + "@decohere/scribe-pino → JSON on stdout). See " + "https://github.com/typesmiths/decohere/blob/main/projects/scribe/README.md\n");
+    }
     supportsLevels(customLevels, logger) {
         if (!customLevels) {
             return;
@@ -83,12 +116,14 @@ export class scribe {
     }
     mergeDefaults(options) {
         const logLevel = resolveLogLevel(options?.logLevel) ?? DefaultLogLevel;
+        // Resolved logLevel must win over options spread (invalid explicit values
+        // would otherwise stick — CU-869emqjq8).
         return {
-            logLevel,
             redactions: DefaultRedactions,
-            ...options
+            ...options,
+            logLevel
         };
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe/src/logger.factory.ts"],"sourcesContent":["import { ConsoleAdapter } from \"./console.adapter.js\";\nimport { resolveLogLevel } from \"./env.js\";\nimport { LoggingConfigurationError } from \"./errors.js\";\nimport type { LoggerAdapter } from \"./logger.adapter.js\";\nimport type { Logger } from \"./logger.type.js\";\nimport { DefaultLogLevel, DefaultRedactions, type ScribeOptions } from \"./types.js\";\n\ntype LoggerFactoryOptions<\n\tT extends string = never,\n\tCustomOnly extends true | false = false,\n> = {\n\toptions?: ScribeOptions<T, CustomOnly>;\n\tadapter: LoggerAdapter;\n};\n\nexport class scribe implements AsyncDisposable {\n\tprivate loggerProvider: LoggerAdapter;\n\tprivate static instance: scribe = new scribe();\n\n\tpublic static logger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname?: string,\n\t\tcustomLevels?: {\n\t\t\t[level in T]: number;\n\t\t},\n\t): Logger<T, CustomOnly> {\n\t\treturn scribe.instance.getLogger<T, CustomOnly>(name, customLevels) as Logger<\n\t\t\tT,\n\t\t\tCustomOnly\n\t\t>;\n\t}\n\n\tpublic static configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tconfigOptions: LoggerFactoryOptions<T, CustomOnly>,\n\t) {\n\t\tconst previous = scribe.instance;\n\t\t// Sync: stop writes into the old ThreadStream before a new worker starts.\n\t\tprevious.retire();\n\t\tscribe.instance = new scribe();\n\t\tconst factory = scribe.instance.configure<T, CustomOnly>(configOptions);\n\t\t// Async drain of the retired adapter (flush / end). Flux/App.stop may\n\t\t// have already done this; reconfigure without stop still needs it.\n\t\tvoid previous.stop();\n\t\treturn factory;\n\t}\n\n\tpublic static flush(cb?: () => void): void {\n\t\tscribe.instance.loggerProvider.flush(cb);\n\t}\n\n\t/** Synchronously stop accepting writes on the active adapter. */\n\tpublic static retire(): void {\n\t\tscribe.instance.retire();\n\t}\n\n\t/** Drain the active adapter and release workers / destinations. */\n\tpublic static async stop(): Promise<void> {\n\t\tawait scribe.instance.stop();\n\t}\n\n\tpublic constructor() {\n\t\t// Initialize with default console adapter\n\t\tthis.loggerProvider = new ConsoleAdapter();\n\t\tconst defaultOptions = this.mergeDefaults();\n\t\tthis.loggerProvider.configure(defaultOptions);\n\t}\n\n\tpublic configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tconfigOptions: LoggerFactoryOptions<T, CustomOnly>,\n\t): (name?: string) => Logger<T, CustomOnly> {\n\t\tconst { adapter, options } = configOptions;\n\t\tconst previous = this.loggerProvider;\n\t\tif (previous !== adapter) {\n\t\t\tprevious.retire();\n\t\t}\n\t\tthis.loggerProvider = adapter;\n\t\tconst defaultsAndOptions = this.mergeDefaults<T, CustomOnly>(options);\n\t\tadapter.configure(defaultsAndOptions);\n\t\tif (previous !== adapter) {\n\t\t\tvoid previous.stop();\n\t\t}\n\t\treturn (name?: string) => adapter.getLogger(name) as Logger<T, CustomOnly>;\n\t}\n\n\tpublic retire(): void {\n\t\tthis.loggerProvider.retire();\n\t}\n\n\tpublic async stop(): Promise<void> {\n\t\tawait this.loggerProvider.stop();\n\t}\n\n\tpublic async [Symbol.asyncDispose](): Promise<void> {\n\t\tawait this.stop();\n\t}\n\n\tpublic getLogger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname?: string,\n\t\tcustomLevels?: {\n\t\t\t[level in T]: number;\n\t\t},\n\t): Logger<T, CustomOnly> {\n\t\t// If custom levels are provided, we need to reconfigure the adapter\n\t\tif (customLevels) {\n\t\t\tconst currentOptions = this.mergeDefaults({ customLevels });\n\t\t\tthis.loggerProvider.configure(currentOptions);\n\t\t}\n\n\t\tconst logger = this.loggerProvider.getLogger(name) as Logger<T, CustomOnly>;\n\t\tthis.supportsLevels(customLevels, logger);\n\t\treturn logger;\n\t}\n\n\tprivate supportsLevels<T extends string = never, CustomOnly extends true = undefined>(\n\t\tcustomLevels: {\n\t\t\t[level in T]: number;\n\t\t},\n\t\tlogger: Logger<T, CustomOnly>,\n\t) {\n\t\tif (!customLevels) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst missingLevel = Object.entries(customLevels).find(\n\t\t\t(key) => !logger.logLevels[key.at(0).toString()],\n\t\t);\n\n\t\tif (missingLevel != null) {\n\t\t\tthrow new LoggingConfigurationError(\n\t\t\t\t`Current logger was not configured for custom level ${missingLevel}, valid levels are: ${JSON.stringify(logger.logLevels)}`,\n\t\t\t);\n\t\t}\n\t\treturn { missingLevel };\n\t}\n\n\tprivate mergeDefaults<T extends string = never, CustomOnly extends true | false = false>(\n\t\toptions?: ScribeOptions<T, CustomOnly>,\n\t): ScribeOptions<T, CustomOnly> {\n\t\tconst logLevel = resolveLogLevel(options?.logLevel) ?? DefaultLogLevel;\n\t\treturn { logLevel, redactions: DefaultRedactions, ...options };\n\t}\n}\n"],"names":["ConsoleAdapter","resolveLogLevel","LoggingConfigurationError","DefaultLogLevel","DefaultRedactions","scribe","loggerProvider","instance","logger","name","customLevels","getLogger","configure","configOptions","previous","retire","factory","stop","flush","cb","defaultOptions","mergeDefaults","adapter","options","defaultsAndOptions","Symbol","asyncDispose","currentOptions","supportsLevels","missingLevel","Object","entries","find","key","logLevels","at","toString","JSON","stringify","logLevel","redactions"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe/src/logger.factory.ts"],"sourcesContent":["import { ConsoleAdapter } from \"./console.adapter.js\";\nimport { resolveLogLevel } from \"./env.js\";\nimport { LoggingConfigurationError } from \"./errors.js\";\nimport type { LoggerAdapter } from \"./logger.adapter.js\";\nimport type { Logger } from \"./logger.type.js\";\nimport { DefaultLogLevel, DefaultRedactions, type ScribeOptions } from \"./types.js\";\n\ntype LoggerFactoryOptions<\n\tT extends string = never,\n\tCustomOnly extends true | false = false,\n> = {\n\toptions?: ScribeOptions<T, CustomOnly>;\n\tadapter: LoggerAdapter;\n};\n\nexport class scribe implements AsyncDisposable {\n\tprivate loggerProvider: LoggerAdapter;\n\t/** True after `configure({ adapter })` — the constructor’s ConsoleAdapter is only a fallback. */\n\tprivate adapterConfigured = false;\n\tprivate defaultAdapterWarned = false;\n\tprivate static instance: scribe = new scribe();\n\n\tpublic static logger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname?: string,\n\t\tcustomLevels?: {\n\t\t\t[level in T]: number;\n\t\t},\n\t): Logger<T, CustomOnly> {\n\t\t// Apply custom levels once against the active adapter; the live handle\n\t\t// re-resolves the underlying logger on each use (CU-869egxmg2).\n\t\tif (customLevels) {\n\t\t\tscribe.instance.getLogger<T, CustomOnly>(name, customLevels);\n\t\t}\n\t\treturn scribe.createLiveLogger<T, CustomOnly>(name);\n\t}\n\n\tpublic static configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tconfigOptions: LoggerFactoryOptions<T, CustomOnly>,\n\t) {\n\t\tconst previous = scribe.instance;\n\t\t// Sync: stop writes into the old ThreadStream before a new worker starts.\n\t\tprevious.retire();\n\t\tscribe.instance = new scribe();\n\t\tscribe.instance.configure<T, CustomOnly>(configOptions);\n\t\t// Async drain of the retired adapter (flush / end). Flux/App.stop may\n\t\t// have already done this; reconfigure without stop still needs it.\n\t\tvoid previous.stop();\n\t\treturn (name?: string) => scribe.logger<T, CustomOnly>(name);\n\t}\n\n\tpublic static flush(cb?: () => void): void {\n\t\tscribe.instance.loggerProvider.flush(cb);\n\t}\n\n\t/** Synchronously stop accepting writes on the active adapter. */\n\tpublic static retire(): void {\n\t\tscribe.instance.retire();\n\t}\n\n\t/** Drain the active adapter and release workers / destinations. */\n\tpublic static async stop(): Promise<void> {\n\t\tawait scribe.instance.stop();\n\t}\n\n\t/**\n\t * Module-level `const log = scribe.logger(...)` must follow a later\n\t * `scribe.configure()` (CLI / Flux / HotReloadServer). Forward every use to\n\t * the active adapter logger for `name`.\n\t */\n\tprivate static createLiveLogger<\n\t\tT extends string = never,\n\t\tCustomOnly extends true | false = false,\n\t>(name?: string): Logger<T, CustomOnly> {\n\t\treturn new Proxy({} as Logger<T, CustomOnly>, {\n\t\t\tget(_target, prop) {\n\t\t\t\tconst underlying = scribe.instance.getLogger<T, CustomOnly>(name) as object;\n\t\t\t\tconst value = Reflect.get(underlying, prop, underlying);\n\t\t\t\treturn typeof value === \"function\"\n\t\t\t\t\t? (value as (...args: never[]) => unknown).bind(underlying)\n\t\t\t\t\t: value;\n\t\t\t},\n\t\t\thas(_target, prop) {\n\t\t\t\tconst underlying = scribe.instance.getLogger<T, CustomOnly>(name) as object;\n\t\t\t\treturn Reflect.has(underlying, prop);\n\t\t\t},\n\t\t});\n\t}\n\n\tpublic constructor() {\n\t\t// Initialize with default console adapter\n\t\tthis.loggerProvider = new ConsoleAdapter();\n\t\tconst defaultOptions = this.mergeDefaults();\n\t\tthis.loggerProvider.configure(defaultOptions);\n\t}\n\n\tpublic configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tconfigOptions: LoggerFactoryOptions<T, CustomOnly>,\n\t): (name?: string) => Logger<T, CustomOnly> {\n\t\tconst { adapter, options } = configOptions;\n\t\tconst previous = this.loggerProvider;\n\t\tif (previous !== adapter) {\n\t\t\tprevious.retire();\n\t\t}\n\t\tthis.loggerProvider = adapter;\n\t\tthis.adapterConfigured = true;\n\t\tconst defaultsAndOptions = this.mergeDefaults<T, CustomOnly>(options);\n\t\tadapter.configure(defaultsAndOptions);\n\t\tif (previous !== adapter) {\n\t\t\tvoid previous.stop();\n\t\t}\n\t\treturn (name?: string) => scribe.logger<T, CustomOnly>(name);\n\t}\n\n\tpublic retire(): void {\n\t\tthis.loggerProvider.retire();\n\t}\n\n\tpublic async stop(): Promise<void> {\n\t\tawait this.loggerProvider.stop();\n\t}\n\n\tpublic async [Symbol.asyncDispose](): Promise<void> {\n\t\tawait this.stop();\n\t}\n\n\tpublic getLogger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname?: string,\n\t\tcustomLevels?: {\n\t\t\t[level in T]: number;\n\t\t},\n\t): Logger<T, CustomOnly> {\n\t\tthis.warnIfDefaultAdapter();\n\n\t\t// If custom levels are provided, we need to reconfigure the adapter\n\t\tif (customLevels) {\n\t\t\tconst currentOptions = this.mergeDefaults({ customLevels });\n\t\t\tthis.loggerProvider.configure(currentOptions);\n\t\t}\n\n\t\tconst logger = this.loggerProvider.getLogger(name) as Logger<T, CustomOnly>;\n\t\tthis.supportsLevels(customLevels, logger);\n\t\treturn logger;\n\t}\n\n\tprivate warnIfDefaultAdapter(): void {\n\t\tif (this.adapterConfigured || this.defaultAdapterWarned) {\n\t\t\treturn;\n\t\t}\n\t\tthis.defaultAdapterWarned = true;\n\t\tprocess.stderr.write(\n\t\t\t\"[scribe] No logger adapter configured; using the default ConsoleAdapter. \" +\n\t\t\t\t\"Configure an adapter at your composition root (for production, prefer \" +\n\t\t\t\t\"@decohere/scribe-pino → JSON on stdout). See \" +\n\t\t\t\t\"https://github.com/typesmiths/decohere/blob/main/projects/scribe/README.md\\n\",\n\t\t);\n\t}\n\n\tprivate supportsLevels<T extends string = never, CustomOnly extends true = undefined>(\n\t\tcustomLevels: {\n\t\t\t[level in T]: number;\n\t\t},\n\t\tlogger: Logger<T, CustomOnly>,\n\t) {\n\t\tif (!customLevels) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst missingLevel = Object.entries(customLevels).find(\n\t\t\t(key) => !logger.logLevels[key.at(0).toString()],\n\t\t);\n\n\t\tif (missingLevel != null) {\n\t\t\tthrow new LoggingConfigurationError(\n\t\t\t\t`Current logger was not configured for custom level ${missingLevel}, valid levels are: ${JSON.stringify(logger.logLevels)}`,\n\t\t\t);\n\t\t}\n\t\treturn { missingLevel };\n\t}\n\n\tprivate mergeDefaults<T extends string = never, CustomOnly extends true | false = false>(\n\t\toptions?: ScribeOptions<T, CustomOnly>,\n\t): ScribeOptions<T, CustomOnly> {\n\t\tconst logLevel = resolveLogLevel(options?.logLevel) ?? DefaultLogLevel;\n\t\t// Resolved logLevel must win over options spread (invalid explicit values\n\t\t// would otherwise stick — CU-869emqjq8).\n\t\treturn { redactions: DefaultRedactions, ...options, logLevel };\n\t}\n}\n"],"names":["ConsoleAdapter","resolveLogLevel","LoggingConfigurationError","DefaultLogLevel","DefaultRedactions","scribe","loggerProvider","adapterConfigured","defaultAdapterWarned","instance","logger","name","customLevels","getLogger","createLiveLogger","configure","configOptions","previous","retire","stop","flush","cb","Proxy","get","_target","prop","underlying","value","Reflect","bind","has","defaultOptions","mergeDefaults","adapter","options","defaultsAndOptions","Symbol","asyncDispose","warnIfDefaultAdapter","currentOptions","supportsLevels","process","stderr","write","missingLevel","Object","entries","find","key","logLevels","at","toString","JSON","stringify","logLevel","redactions"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/scribe",
-  "version": "0.0.1-dev.77",
+  "version": "0.0.1-dev.79",
   "description": "Structured logging interface with pluggable adapters",
   "keywords": [
     "typescript",

package/types/src/logger.factory.d.ts

@@ -7,6 +7,9 @@ type LoggerFactoryOptions<T extends string = never, CustomOnly extends true | fa
 };
 export declare class scribe implements AsyncDisposable {
     private loggerProvider;
+    /** True after `configure({ adapter })` — the constructor’s ConsoleAdapter is only a fallback. */
+    private adapterConfigured;
+    private defaultAdapterWarned;
     private static instance;
     static logger<T extends string = never, CustomOnly extends true | false = false>(name?: string, customLevels?: {
         [level in T]: number;
@@ -17,6 +20,12 @@ export declare class scribe implements AsyncDisposable {
     static retire(): void;
     /** Drain the active adapter and release workers / destinations. */
     static stop(): Promise<void>;
+    /**
+     * Module-level `const log = scribe.logger(...)` must follow a later
+     * `scribe.configure()` (CLI / Flux / HotReloadServer). Forward every use to
+     * the active adapter logger for `name`.
+     */
+    private static createLiveLogger;
     constructor();
     configure<T extends string = never, CustomOnly extends true | false = false>(configOptions: LoggerFactoryOptions<T, CustomOnly>): (name?: string) => Logger<T, CustomOnly>;
     retire(): void;
@@ -25,6 +34,7 @@ export declare class scribe implements AsyncDisposable {
     getLogger<T extends string = never, CustomOnly extends true | false = false>(name?: string, customLevels?: {
         [level in T]: number;
     }): Logger<T, CustomOnly>;
+    private warnIfDefaultAdapter;
     private supportsLevels;
     private mergeDefaults;
 }