@vvlad1973/simple-logger 2.1.9 → 2.1.10

package/dist/__test__/simple-logger.test.js

@@ -1,66 +1,66 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import SimpleLogger from '../classes/simple-logger.js';
-describe('SimpleLogger', () => {
-    let consoleSpy;
-    beforeEach(() => {
-        consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-    });
-    afterEach(() => {
-        consoleSpy.mockRestore();
-    });
-    it('should log using console when no external logger is provided', () => {
-        const logger = new SimpleLogger();
-        logger.info('test message');
-        expect(consoleSpy).toHaveBeenCalledOnce();
-        expect(consoleSpy.mock.calls[0][0]).toMatch(/test message/);
-    });
-    it('should not log below current level', () => {
-        const logger = new SimpleLogger(null, { level: 'warn' });
-        logger.info('should not log');
-        logger.warn('should log');
-        expect(consoleSpy).toHaveBeenCalledOnce();
-        expect(consoleSpy.mock.calls[0][0]).toMatch(/should log/);
-    });
-    it('should respect msgPrefix', () => {
-        const logger = new SimpleLogger(null, { msgPrefix: '[PREFIX]' });
-        logger.info('message');
-        expect(consoleSpy.mock.calls[0][0]).toMatch(/\[PREFIX\]/);
-    });
-    it('should use external logger methods if provided', () => {
-        const external = {
-            info: vi.fn(),
-            level: 'info',
-        };
-        const logger = new SimpleLogger(external);
-        logger.info('external log');
-        expect(external.info).toHaveBeenCalledOnce();
-        expect(external.info).toHaveBeenCalledWith('external log');
-    });
-    it('should fallback to console for invalid external logger', () => {
-        const logger = new SimpleLogger({});
-        logger.info('fallback');
-        expect(consoleSpy).toHaveBeenCalled();
-    });
-    it('should create child logger with merged bindings', () => {
-        const logger = new SimpleLogger(null, { bindings: { user: 'A' } });
-        const child = logger.child({ request: '123' });
-        child.info('child message');
-        expect(consoleSpy.mock.calls.length).toBe(1);
-        const output = consoleSpy.mock.calls[0][0];
-        expect(output).toMatch(/user=A/);
-        expect(output).toMatch(/request=123/);
-        expect(output).toMatch(/child message/);
-    });
-    it('should call .child if external logger supports it', () => {
-        const childFn = vi.fn(() => ({
-            info: vi.fn(),
-            level: 'info',
-        }));
-        const external = { level: 'info', child: childFn, info: vi.fn() };
-        const logger = new SimpleLogger(external);
-        const child = logger.child({ traceId: 'xyz' });
-        child.info('from child');
-        expect(childFn).toHaveBeenCalledWith({ traceId: 'xyz' });
-    });
-});
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import SimpleLogger from '../classes/simple-logger.js';
+describe('SimpleLogger', () => {
+    let consoleSpy;
+    beforeEach(() => {
+        consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    it('should log using console when no external logger is provided', () => {
+        const logger = new SimpleLogger();
+        logger.info('test message');
+        expect(consoleSpy).toHaveBeenCalledOnce();
+        expect(consoleSpy.mock.calls[0][0]).toMatch(/test message/);
+    });
+    it('should not log below current level', () => {
+        const logger = new SimpleLogger(null, { level: 'warn' });
+        logger.info('should not log');
+        logger.warn('should log');
+        expect(consoleSpy).toHaveBeenCalledOnce();
+        expect(consoleSpy.mock.calls[0][0]).toMatch(/should log/);
+    });
+    it('should respect msgPrefix', () => {
+        const logger = new SimpleLogger(null, { msgPrefix: '[PREFIX]' });
+        logger.info('message');
+        expect(consoleSpy.mock.calls[0][0]).toMatch(/\[PREFIX\]/);
+    });
+    it('should use external logger methods if provided', () => {
+        const external = {
+            info: vi.fn(),
+            level: 'info',
+        };
+        const logger = new SimpleLogger(external);
+        logger.info('external log');
+        expect(external.info).toHaveBeenCalledOnce();
+        expect(external.info).toHaveBeenCalledWith('external log');
+    });
+    it('should fallback to console for invalid external logger', () => {
+        const logger = new SimpleLogger({});
+        logger.info('fallback');
+        expect(consoleSpy).toHaveBeenCalled();
+    });
+    it('should create child logger with merged bindings', () => {
+        const logger = new SimpleLogger(null, { bindings: { user: 'A' } });
+        const child = logger.child({ request: '123' });
+        child.info('child message');
+        expect(consoleSpy.mock.calls.length).toBe(1);
+        const output = consoleSpy.mock.calls[0][0];
+        expect(output).toMatch(/user=A/);
+        expect(output).toMatch(/request=123/);
+        expect(output).toMatch(/child message/);
+    });
+    it('should call .child if external logger supports it', () => {
+        const childFn = vi.fn(() => ({
+            info: vi.fn(),
+            level: 'info',
+        }));
+        const external = { level: 'info', child: childFn, info: vi.fn() };
+        const logger = new SimpleLogger(external);
+        const child = logger.child({ traceId: 'xyz' });
+        child.info('from child');
+        expect(childFn).toHaveBeenCalledWith({ traceId: 'xyz' });
+    });
+});
 //# sourceMappingURL=simple-logger.test.js.map

package/dist/classes/simple-logger.d.ts

@@ -1,125 +1,125 @@
-/**
- * A module for simple logging with various logging levels.
- * @module SimpleLogger
- */
-import { ExternalLogger, LogFn, LoggerFactory, LoggerLevel, LoggerOptions } from '../types/simple-logger.types.js';
-export default class SimpleLogger {
-    private currentLevelIndex;
-    private logger;
-    private bindings;
-    private msgPrefix?;
-    private enabled;
-    isExternal: boolean;
-    static readonly noop: LogFn;
-    trace: LogFn;
-    debug: LogFn;
-    info: LogFn;
-    warn: LogFn;
-    error: LogFn;
-    fatal: LogFn;
-    silent: LogFn;
-    /**
-     * Initializes a new instance of the SimpleLogger class.
-     *
-     * @param {ExternalLogger | LoggerFactory | null} externalLogger - The external logger to use, or null to use the console.
-     * @param {LoggerOptions} [options={}] - Options for the logger, such as the logging level and bindings.
-     */
-    constructor(externalLogger?: ExternalLogger | LoggerFactory | null, options?: LoggerOptions);
-    /**
-     * Resolves the effective logging level based on the provided logger and explicit level.
-     *
-     * @param {ExternalLogger | Console} logger - The logger to resolve the level for.
-     * @param {LoggerLevel} [explicitLevel] - The explicit logging level to use, if provided.
-     * @return {LoggerLevel} The resolved effective logging level.
-     */
-    private resolveEffectiveLevel;
-    /**
-     * Initializes the logger with the provided external logger and options.
-     *
-     * Handles different cases for the external logger, including:
-     * - No external logger provided (falls back to console)
-     * - External logger is a factory function (e.g. pino)
-     * - External logger is invalid or console (falls back to console)
-     * - External logger is provided without parameters
-     * - External logger has a .child() method
-     * - External logger does not have a .child() method (uses directly)
-     *
-     * @param {ExternalLogger | LoggerFactory | null} externalLogger - The external logger to use, or null to use the console.
-     * @param {LoggerOptions} options - Options for the logger, such as the logging level and bindings.
-     * @return {void}
-     */
-    private initLogger;
-    /**
-     * Updates the logging methods based on the current logging level and external logger configuration.
-     *
-     * Iterates over the available logging levels and sets the corresponding logging method to either call the external log method or the internal pretty format log method, depending on the logger configuration.
-     *
-     * @return {void}
-     */
-    private updateLoggingMethods;
-    /**
-     * Calls the external log method for the specified level with the provided arguments.
-     *
-     * @param {LoggerLevel} level - The logging level to use for the external log method.
-     * @param {unknown[]} args - The arguments to pass to the external log method.
-     * @return {void}
-     */
-    private callExternalLogMethod;
-    /**
-     * Formats and logs a message with the specified level and arguments.
-     *
-     * @param {LoggerLevel} level - The logging level to use for the log message.
-     * @param {unknown[]} args - The arguments to use when formatting the log message.
-     * @return {void}
-     */
-    private prettyFormatLog;
-    /**
-     * Retrieves the current logging level.
-     *
-     * @return {LoggerLevel} The current logging level.
-     */
-    getLevel(): LoggerLevel;
-    /**
-     * Sets the logging level.
-     *
-     * @param {LoggerLevel} level - The logging level to set.
-     * @return {void}
-     */
-    setLevel(level: LoggerLevel): void;
-    /**
-     * Enables the logger.
-     *
-     * @return {void}
-     */
-    enable(): void;
-    /**
-     * Disables the logger.
-     *
-     * @return {void} Nothing is returned.
-     */
-    disable(): void;
-    /**
-     * Creates a new child logger with the merged bindings.
-     *
-     * If the external logger supports the `child` method, it will be used to create the child logger.
-     * Otherwise, a new SimpleLogger instance will be created with the merged bindings.
-     *
-     * @param {Record<string, unknown>} newBindings - The new bindings to merge with the existing bindings.
-     * @return {SimpleLogger} The new child logger instance.
-     */
-    child(newBindings: Record<string, unknown>): SimpleLogger;
-    /**
-     * Logs the start of a function.
-     *
-     * @param {string} name - Optional function name to log. If not provided, the caller function name will be used.
-     * @return {void}
-     */
-    logFunctionStart(name?: string): void;
-    /**
-     * Logs the end of a function.
-     *
-     * @param {string} name - Optional function name to log. If not provided, the caller function name will be used.
-     * @return {void}
-     */
-    logFunctionEnd(name?: string): void;
-}
+/**
+ * A module for simple logging with various logging levels.
+ * @module SimpleLogger
+ */
+import { type ExternalLogger, type LogFn, type LoggerFactory, type LoggerLevel, type LoggerOptions } from '../types/simple-logger.types.js';
+export default class SimpleLogger {
+    private currentLevelIndex;
+    private logger;
+    private bindings;
+    private msgPrefix?;
+    private enabled;
+    isExternal: boolean;
+    static readonly noop: LogFn;
+    trace: LogFn;
+    debug: LogFn;
+    info: LogFn;
+    warn: LogFn;
+    error: LogFn;
+    fatal: LogFn;
+    silent: LogFn;
+    /**
+     * Initializes a new instance of the SimpleLogger class.
+     *
+     * @param {ExternalLogger | LoggerFactory | null} externalLogger - The external logger to use, or null to use the console.
+     * @param {LoggerOptions} [options={}] - Options for the logger, such as the logging level and bindings.
+     */
+    constructor(externalLogger?: ExternalLogger | LoggerFactory | null, options?: LoggerOptions);
+    /**
+     * Resolves the effective logging level based on the provided logger and explicit level.
+     *
+     * @param {ExternalLogger | Console} logger - The logger to resolve the level for.
+     * @param {LoggerLevel} [explicitLevel] - The explicit logging level to use, if provided.
+     * @return {LoggerLevel} The resolved effective logging level.
+     */
+    private resolveEffectiveLevel;
+    /**
+     * Initializes the logger with the provided external logger and options.
+     *
+     * Handles different cases for the external logger, including:
+     * - No external logger provided (falls back to console)
+     * - External logger is a factory function (e.g. pino)
+     * - External logger is invalid or console (falls back to console)
+     * - External logger is provided without parameters
+     * - External logger has a .child() method
+     * - External logger does not have a .child() method (uses directly)
+     *
+     * @param {ExternalLogger | LoggerFactory | null} externalLogger - The external logger to use, or null to use the console.
+     * @param {LoggerOptions} options - Options for the logger, such as the logging level and bindings.
+     * @return {void}
+     */
+    private initLogger;
+    /**
+     * Updates the logging methods based on the current logging level and external logger configuration.
+     *
+     * Iterates over the available logging levels and sets the corresponding logging method to either call the external log method or the internal pretty format log method, depending on the logger configuration.
+     *
+     * @return {void}
+     */
+    private updateLoggingMethods;
+    /**
+     * Calls the external log method for the specified level with the provided arguments.
+     *
+     * @param {LoggerLevel} level - The logging level to use for the external log method.
+     * @param {unknown[]} args - The arguments to pass to the external log method.
+     * @return {void}
+     */
+    private callExternalLogMethod;
+    /**
+     * Formats and logs a message with the specified level and arguments.
+     *
+     * @param {LoggerLevel} level - The logging level to use for the log message.
+     * @param {unknown[]} args - The arguments to use when formatting the log message.
+     * @return {void}
+     */
+    private prettyFormatLog;
+    /**
+     * Retrieves the current logging level.
+     *
+     * @return {LoggerLevel} The current logging level.
+     */
+    getLevel(): LoggerLevel;
+    /**
+     * Sets the logging level.
+     *
+     * @param {LoggerLevel} level - The logging level to set.
+     * @return {void}
+     */
+    setLevel(level: LoggerLevel): void;
+    /**
+     * Enables the logger.
+     *
+     * @return {void}
+     */
+    enable(): void;
+    /**
+     * Disables the logger.
+     *
+     * @return {void} Nothing is returned.
+     */
+    disable(): void;
+    /**
+     * Creates a new child logger with the merged bindings.
+     *
+     * If the external logger supports the `child` method, it will be used to create the child logger.
+     * Otherwise, a new SimpleLogger instance will be created with the merged bindings.
+     *
+     * @param {Record<string, unknown>} newBindings - The new bindings to merge with the existing bindings.
+     * @return {SimpleLogger} The new child logger instance.
+     */
+    child(newBindings: Record<string, unknown>): SimpleLogger;
+    /**
+     * Logs the start of a function.
+     *
+     * @param {string} name - Optional function name to log. If not provided, the caller function name will be used.
+     * @return {void}
+     */
+    logFunctionStart(name?: string): void;
+    /**
+     * Logs the end of a function.
+     *
+     * @param {string} name - Optional function name to log. If not provided, the caller function name will be used.
+     * @return {void}
+     */
+    logFunctionEnd(name?: string): void;
+}