metalog 3.1.18 → 4.0.1-prerelease

package/README.md

@@ -14,21 +14,351 @@
 ## Usage
 
 ```js
-const logger = await metalog.openLog({
+const logger = await Logger.create({
   path: './log', // absolute or relative path
   workerId: 7, // mark for process or thread
-  writeInterval: 3000, // flush log to disk interval
-  writeBuffer: 64 * 1024, // buffer size (default 64kb)
-  keepDays: 5, // delete after N days, 0 - disable
+  flushInterval: 3000, // flush log to disk interval (default: 3s)
+  writeBuffer: 64 * 1024, // buffer size (default: 64kb)
+  keepDays: 5, // delete after N days, 0 - disable (default: 1)
   home: process.cwd(), // remove substring from paths
-  json: false, // print logs in JSON format, by default false
+  json: false, // print logs in JSON format (default: false)
+  toFile: ['log', 'info', 'warn', 'error'], // tags to write to file (default: all)
+  toStdout: ['log', 'info', 'warn', 'error'], // tags to write to stdout (default: all)
+  createStream: () => fs.createWriteStream, // custom stream factory (optional)
+  crash: 'flush', // crash handling: 'flush' to flush buffer on exit (optional)
 });
 
 const { console } = logger;
+
 console.log('Test message');
+console.info('Info message');
+console.warn('Warning message');
+console.error('Error message');
+console.debug('Debug message');
+
+console.assert(true, 'Assertion passed');
+console.assert(false, 'Assertion failed');
+console.count('counter');
+console.count('counter');
+console.countReset('counter');
+
+console.time('operation');
+// ... some operation ...
+console.timeEnd('operation');
+console.timeLog('operation', 'Checkpoint');
+
+console.group('Group 1');
+console.log('Nested message');
+console.groupCollapsed('Group 2');
+console.log('Collapsed group message');
+console.groupEnd();
+console.groupEnd();
+
+console.dir({ key: 'value' });
+console.dirxml('<div>HTML content</div>');
+console.table([
+  { name: 'John', age: 30 },
+  { name: 'Jane', age: 25 },
+]);
+
+console.trace('Trace message');
+
 await logger.close();
 ```
 
+## Console API Compatibility
+
+Metalog provides a fully compatible console implementation that supports all Node.js console methods:
+
+- `console.log([data][, ...args])` - General logging
+- `console.info([data][, ...args])` - Informational messages
+- `console.warn([data][, ...args])` - Warning messages
+- `console.error([data][, ...args])` - Error messages
+- `console.debug([data][, ...args])` - Debug messages
+- `console.assert(value[, ...message])` - Assertion testing
+- `console.clear()` - Clear the console
+- `console.count([label])` - Count occurrences
+- `console.countReset([label])` - Reset counter
+- `console.dir(obj[, options])` - Object inspection
+- `console.dirxml(...data)` - XML/HTML inspection
+- `console.group([...label])` - Start group
+- `console.groupCollapsed()` - Start collapsed group
+- `console.groupEnd()` - End group
+- `console.table(tabularData[, properties])` - Table display
+- `console.time([label])` - Start timer
+- `console.timeEnd([label])` - End timer
+- `console.timeLog([label][, ...data])` - Log timer value
+- `console.trace([message][, ...args])` - Stack trace
+
+All methods maintain the same behavior as Node.js native console, with output routed through the metalog system for consistent formatting and file logging.
+
+## Configuration Options
+
+### LoggerOptions
+
+| Option          | Type       | Default                                     | Description                                         |
+| --------------- | ---------- | ------------------------------------------- | --------------------------------------------------- |
+| `path`          | `string`   | **required**                                | Directory path for log files (absolute or relative) |
+| `home`          | `string`   | **required**                                | Base path to remove from stack traces               |
+| `workerId`      | `number`   | `undefined`                                 | Worker/process identifier (appears as W0, W1, etc.) |
+| `flushInterval` | `number`   | `3000`                                      | Flush buffer to disk interval in milliseconds       |
+| `writeBuffer`   | `number`   | `65536`                                     | Buffer size threshold before flushing (64KB)        |
+| `keepDays`      | `number`   | `1`                                         | Days to keep log files (0 = disable rotation)       |
+| `json`          | `boolean`  | `false`                                     | Output logs in JSON format                          |
+| `toFile`        | `string[]` | `['log', 'info', 'warn', 'debug', 'error']` | Log tags to write to file                           |
+| `toStdout`      | `string[]` | `['log', 'info', 'warn', 'debug', 'error']` | Log tags to write to stdout                         |
+| `createStream`  | `function` | `fs.createWriteStream`                      | Custom stream factory function                      |
+| `crash`         | `string`   | `undefined`                                 | Crash handling mode ('flush' to flush on exit)      |
+
+### Log Tags
+
+Metalog supports five log tags that can be filtered independently for file and console output:
+
+- `log` - General logging
+- `info` - Informational messages
+- `warn` - Warning messages
+- `debug` - Debug messages
+- `error` - Error messages
+
+## Advanced Usage
+
+### Custom Stream Factory
+
+```js
+const logger = await Logger.create({
+  path: './log',
+  home: process.cwd(),
+  createStream: (filePath) => {
+    // Custom compression stream
+    const fs = require('fs');
+    const zlib = require('zlib');
+    const gzip = zlib.createGzip();
+    const writeStream = fs.createWriteStream(filePath + '.gz');
+    return gzip.pipe(writeStream);
+  },
+});
+```
+
+### Selective Logging
+
+```js
+// Only log errors to file, all tags to console
+const logger = await Logger.create({
+  path: './log',
+  home: process.cwd(),
+  toFile: ['error'],
+  toStdout: ['log', 'info', 'warn', 'debug', 'error'],
+});
+
+// Only log info and above tags to both file and console
+const logger = await Logger.create({
+  path: './log',
+  home: process.cwd(),
+  toFile: ['info', 'warn', 'error'],
+  toStdout: ['info', 'warn', 'error'],
+});
+```
+
+### JSON Logging
+
+```js
+const logger = await Logger.create({
+  path: './log',
+  home: process.cwd(),
+  json: true,
+});
+
+logger.console.info('User action', { userId: 123, action: 'login' });
+// Output: {"timestamp":"2025-01-07T10:30:00.000Z","worker":"W0","tag":"info","message":"User action","userId":123,"action":"login"}
+```
+
+### Log Rotation and Cleanup
+
+```js
+const logger = await Logger.create({
+  path: './log',
+  home: process.cwd(),
+  keepDays: 7, // Keep logs for 7 days
+  workerId: 1,
+});
+
+// Manual rotation
+await logger.rotate();
+
+// Log files are automatically rotated daily
+// Old files are cleaned up based on keepDays setting
+```
+
+### Error Handling
+
+```js
+const logger = await Logger.create({
+  path: './log',
+  home: process.cwd(),
+  crash: 'flush', // Flush buffer on process exit
+});
+
+logger.on('error', (error) => {
+  console.error('Logger error:', error.message);
+});
+
+// Graceful shutdown
+process.on('SIGTERM', async () => {
+  await logger.close();
+  process.exit(0);
+});
+```
+
+## API Reference
+
+### Logger Class
+
+#### Constructor
+
+```js
+new Logger(options: LoggerOptions): Promise<Logger>
+```
+
+#### Static Methods
+
+- `Logger.create(options: LoggerOptions): Promise<Logger>` - Create and open logger
+
+#### Instance Methods
+
+- `open(): Promise<Logger>` - Open log file and start logging
+- `close(): Promise<void>` - Close logger and flush remaining data
+- `rotate(): Promise<void>` - Manually trigger log rotation
+- `write(tag: string, indent: number, args: unknown[]): void` - Low-level write method
+- `flush(callback?: (error?: Error) => void): void` - Flush buffer to disk
+
+#### Properties
+
+- `active: boolean` - Whether logger is currently active
+- `path: string` - Log directory path
+- `home: string` - Home directory for path normalization
+- `console: Console` - Console instance for logging
+
+### BufferedStream Class
+
+```js
+const stream = new BufferedStream({
+  stream: fs.createWriteStream('output.log'),
+  writeBuffer: 32 * 1024, // 32KB buffer
+  flushInterval: 5000, // 5 second flush interval
+});
+
+stream.write(Buffer.from('data'));
+stream.flush();
+await stream.close();
+```
+
+### Formatter Class
+
+```js
+const formatter = new Formatter({
+  worker: 'W1',
+  home: '/app',
+  json: false,
+});
+
+const formatted = formatter.formatPretty('info', 0, ['Message']);
+const jsonOutput = formatter.formatJson('error', 0, [error]);
+```
+
+## Best Practices
+
+### Performance Optimization
+
+1. **Buffer Size**: Adjust `writeBuffer` based on your log volume
+   - High volume: 128KB or larger
+   - Low volume: 16KB or smaller
+
+2. **Flush Interval**: Balance between performance and data safety
+   - Production: 3-10 seconds
+   - Development: 1-3 seconds
+
+3. **Selective Logging**: Use `toFile` and `toStdout` to reduce I/O
+   ```js
+   // Production: Only errors to file, warnings+ to console
+   toFile: ['error'],
+   toStdout: ['warn', 'error']
+   ```
+
+### Log Management
+
+1. **Rotation Strategy**: Set appropriate `keepDays` based on storage
+2. **Path Organization**: Use structured paths for multi-service deployments
+
+   ```js
+   path: `/var/log/app/${process.env.NODE_ENV}/${process.env.SERVICE_NAME}`;
+   ```
+
+3. **Error Handling**: Always handle logger errors
+   ```js
+   logger.on('error', (error) => {
+     // Fallback logging or alerting
+   });
+   ```
+
+### Development vs Production
+
+```js
+const isDevelopment = process.env.NODE_ENV === 'development';
+
+const logger = await Logger.create({
+  path: './log',
+  home: process.cwd(),
+  json: !isDevelopment, // JSON in production, pretty in dev
+  toFile: isDevelopment ? ['log', 'info', 'warn', 'error'] : ['error'],
+  toStdout: isDevelopment
+    ? ['log', 'info', 'warn', 'debug', 'error']
+    : ['warn', 'error'],
+  flushInterval: isDevelopment ? 1000 : 5000,
+  keepDays: isDevelopment ? 1 : 30,
+});
+```
+
+## Troubleshooting
+
+### Common Issues
+
+**Logs not appearing in files:**
+
+- Check `path` directory exists and is writable
+- Verify `toFile` array includes desired log tags
+- Ensure logger is properly opened with `await logger.open()`
+
+**High memory usage:**
+
+- Reduce `writeBuffer` size
+- Increase `flushInterval` frequency
+- Use selective logging with `toFile`/`toStdout`
+
+**Missing logs on crash:**
+
+- Set `crash: 'flush'` option
+- Handle process signals properly
+- Use try/catch around critical operations
+
+**Performance issues:**
+
+- Use JSON format for high-volume logging
+- Disable file logging for debug tags in production
+- Consider using separate loggers for different components
+
+### Debug Mode
+
+```js
+// Enable debug logging
+const logger = await Logger.create({
+  path: './log',
+  home: process.cwd(),
+  toStdout: ['debug', 'info', 'warn', 'error'],
+});
+
+logger.console.debug('Debug information', { data: 'value' });
+```
+
 ## License & Contributors
 
 Copyright (c) 2017-2025 [Metarhia contributors](https://github.com/metarhia/metalog/graphs/contributors).

package/metalog.d.ts

@@ -5,70 +5,97 @@ interface LoggerOptions {
   home: string;
   workerId?: number;
   createStream?: () => NodeJS.WritableStream;
-  writeInterval: number;
-  writeBuffer: number;
-  keepDays: number;
+  writeBuffer?: number;
+  flushInterval?: number;
+  keepDays?: number;
   json?: boolean;
   toFile?: Array<string>;
   toStdout?: Array<string>;
   crash?: string;
 }
 
-interface Console {
-  assert(assertion: unknown, ...args: unknown[]): void;
+interface BufferedStreamOptions {
+  stream?: NodeJS.WritableStream;
+  writeBuffer?: number;
+  flushInterval?: number;
+}
+
+interface FormatterOptions {
+  json?: boolean;
+  worker?: string;
+  home?: string;
+}
+
+export class BufferedStream extends EventEmitter {
+  constructor(options?: BufferedStreamOptions);
+  write(buffer: Buffer): void;
+  flush(callback?: (error?: Error) => void): void;
+  close(): Promise<void>;
+}
+
+export class Formatter {
+  constructor(options?: FormatterOptions);
+  format(tag: string, indent: number, args: unknown[]): string;
+  formatPretty(tag: string, indent: number, args: unknown[]): string;
+  formatFile(tag: string, indent: number, args: unknown[]): string;
+  formatJson(tag: string, indent: number, args: unknown[]): string;
+  normalizeStack(stack: string): string;
+  expandError(error: Error): unknown;
+}
+
+export class Console {
+  constructor(logger: Logger);
+  assert(value: unknown, ...message: unknown[]): void;
   clear(): void;
   count(label?: string): void;
   countReset(label?: string): void;
-  debug(...args: unknown[]): void;
-  dir(...args: unknown[]): void;
-  trace(...args: unknown[]): void;
-  info(...args: unknown[]): void;
-  log(...args: unknown[]): void;
-  warn(...args: unknown[]): void;
-  error(...args: unknown[]): void;
-  group(...args: unknown[]): void;
-  groupCollapsed(...args: unknown[]): void;
+  debug(data: unknown, ...args: unknown[]): void;
+  dir(obj: unknown, options?: unknown): void;
+  dirxml(...data: unknown[]): void;
+  error(data?: unknown, ...args: unknown[]): void;
+  group(...label: unknown[]): void;
+  groupCollapsed(...label: unknown[]): void;
   groupEnd(): void;
-  table(tabularData: unknown): void;
+  info(data?: unknown, ...args: unknown[]): void;
+  log(data?: unknown, ...args: unknown[]): void;
+  table(tabularData: unknown, properties?: string[]): void;
   time(label?: string): void;
   timeEnd(label?: string): void;
-  timeLog(label: string, ...args: unknown[]): void;
+  timeLog(label?: string, ...data: unknown[]): void;
+  trace(message?: unknown, ...args: unknown[]): void;
+  warn(data?: unknown, ...args: unknown[]): void;
 }
 
 export class Logger extends EventEmitter {
   active: boolean;
   path: string;
-  workerId: string;
-  createStream: () => NodeJS.WritableStream;
-  writeInterval: number;
-  writeBuffer: number;
-  keepDays: number;
   home: string;
-  json: boolean;
-  stream: NodeJS.WritableStream;
-  reopenTimer: NodeJS.Timer;
-  flushTimer: NodeJS.Timer;
-  lock: boolean;
-  buffer: Array<Buffer>;
-  bufferLength: number;
-  file: string;
-  toFile: Record<string, boolean>;
-  fsEnabled: boolean;
-  toStdout: Record<string, boolean>;
   console: Console;
-  constructor(args: LoggerOptions);
-  createLogDir(): Promise<void>;
+
+  constructor(options: LoggerOptions);
+  static create(options: LoggerOptions): Promise<Logger>;
   open(): Promise<Logger>;
   close(): Promise<void>;
   rotate(): Promise<void>;
-  format(type: string, indent: number, ...args: unknown[]): string;
-  formatPretty(type: string, indent: number, ...args: unknown[]): string;
-  formatFile(type: string, indent: number, ...args: unknown[]): string;
-  formatJson(type: string, indent: number, ...args: unknown[]): string;
-  write(type: string, indent: number, ...args: unknown[]): void;
-  flush(callback?: (err?: Error) => void): void;
-  normalizeStack(stack: string): string;
-  expandError(err: Error): unknown;
+  write(tag: string, indent: number, args: unknown[]): void;
+  flush(callback?: (error?: Error) => void): void;
+
+  #options: LoggerOptions;
+  #worker: string;
+  #createStream: () => NodeJS.WritableStream;
+  #keepDays: number;
+  #stream: NodeJS.WritableStream | null;
+  #rotationTimer: NodeJS.Timer | null;
+  #file: string;
+  #fsEnabled: boolean;
+  #toFile: Record<string, boolean> | null;
+  #toStdout: Record<string, boolean> | null;
+  #buffer: BufferedStream | null;
+  #formatter: Formatter;
+
+  #createDir(): Promise<void>;
+  #setupCrashHandling(): void;
 }
 
-export function openLog(args: LoggerOptions): Promise<Logger>;
+export function nowDays(): number;
+export function nameToDays(fileName: string): number;

package/metalog.js

@@ -4,26 +4,26 @@ const fs = require('node:fs');
 const fsp = fs.promises;
 const path = require('node:path');
 const util = require('node:util');
-const events = require('node:events');
+const EventEmitter = require('node:events');
 const readline = require('node:readline');
 const metautil = require('metautil');
 const concolor = require('concolor');
 
 const DAY_MILLISECONDS = metautil.duration('1d');
-const DEFAULT_WRITE_INTERVAL = metautil.duration('3s');
-const DEFAULT_BUFFER_SIZE = 64 * 1024;
+const DEFAULT_FLUSH_INTERVAL = metautil.duration('3s');
+const DEFAULT_BUFFER_THRESHOLD = 64 * 1024;
 const DEFAULT_KEEP_DAYS = 1;
 const STACK_AT = '  at ';
-const TYPE_LENGTH = 6;
+const TAG_LENGTH = 6;
 const LINE_SEPARATOR = ';';
 const INDENT = 2;
 const DATE_LEN = 'YYYY-MM-DD'.length;
 const TIME_START = DATE_LEN + 1;
 const TIME_END = TIME_START + 'HH:MM:SS'.length;
 
-const LOG_TYPES = ['log', 'info', 'warn', 'debug', 'error'];
+const LOG_TAGS = ['log', 'info', 'warn', 'debug', 'error'];
 
-const TYPE_COLOR = concolor({
+const TAG_COLOR = concolor({
   log: 'b,black/white',
   info: 'b,white/blue',
   warn: 'b,black/yellow',
@@ -47,11 +47,9 @@ const DEFAULT_FLAGS = {
   error: false,
 };
 
-const logTypes = (types) => {
+const logTags = (tags) => {
   const flags = { ...DEFAULT_FLAGS };
-  for (const type of types) {
-    flags[type] = true;
-  }
+  for (const tag of tags) flags[tag] = true;
   return flags;
 };
 
@@ -64,9 +62,17 @@ const nowDays = () => {
   return Math.floor(date.getTime() / DAY_MILLISECONDS);
 };
 
-const nameToDays = (fileName) => {
+const nameToDays = (fileName = '') => {
+  if (fileName.length < DATE_LEN) {
+    throw new Error(`Invalid filename: ${fileName}`);
+  }
   const date = fileName.substring(0, DATE_LEN);
-  const fileTime = new Date(date).getTime();
+  const [year, month, day] = date.split('-').map(Number);
+  const fileDate = new Date(year, month - 1, day, 0, 0, 0, 0);
+  const fileTime = fileDate.getTime();
+  if (isNaN(fileTime)) {
+    throw new Error(`Invalid filename: ${fileName}`);
+  }
   return Math.floor(fileTime / DAY_MILLISECONDS);
 };
 
@@ -77,22 +83,148 @@ const getNextReopen = () => {
   return nextDate - curTime + DAY_MILLISECONDS;
 };
 
+class BufferedStream extends EventEmitter {
+  #writable = null;
+  #buffers = [];
+  #size = 0;
+  #threshold = DEFAULT_BUFFER_THRESHOLD;
+  #flushing = false;
+  #flushTimer = null;
+
+  constructor(options = {}) {
+    super();
+    const { stream, writeBuffer, flushInterval } = options;
+    if (!stream) throw new Error('Stream is required');
+    this.#writable = stream;
+    if (writeBuffer) this.#threshold = writeBuffer;
+    const interval = flushInterval || DEFAULT_FLUSH_INTERVAL;
+    this.#flushTimer = setInterval(() => void this.flush(), interval);
+  }
+
+  write(buffer) {
+    this.#buffers.push(buffer);
+    this.#size += buffer.length;
+    if (this.#size >= this.#threshold) this.flush();
+  }
+
+  flush(callback) {
+    if (this.#flushing) {
+      if (callback) this.once('drain', callback);
+      return;
+    }
+    if (this.#size === 0) {
+      if (callback) callback();
+      return;
+    }
+    if (this.#writable.destroyed || this.#writable.closed) {
+      if (callback) callback();
+      return;
+    }
+    this.#flushing = true;
+    const buffer = Buffer.concat(this.#buffers);
+    this.#buffers.length = 0;
+    this.#size = 0;
+    this.#writable.write(buffer, (error) => {
+      this.#flushing = false;
+      this.emit('drain');
+      if (callback) callback(error);
+    });
+  }
+
+  async close() {
+    clearInterval(this.#flushTimer);
+    return new Promise((resolve, reject) => {
+      this.flush((error) => {
+        if (error) return void reject(error);
+        this.#writable.end(resolve);
+      });
+    });
+  }
+}
+
+class Formatter {
+  #worker = 'W0';
+  #home = './';
+
+  constructor(options = {}) {
+    const { worker, home } = options;
+    if (worker) this.#worker = worker;
+    if (home) this.#home = home;
+  }
+
+  format(tag, indent, args) {
+    let line = util.format(...args);
+    if (tag === 'error' || tag === 'debug') line = this.normalizeStack(line);
+    return ' '.repeat(indent) + line;
+  }
+
+  formatPretty(tag, indent, args) {
+    const dateTime = new Date().toISOString();
+    const message = this.format(tag, indent, args);
+    const normalColor = TEXT_COLOR[tag];
+    const markColor = TAG_COLOR[tag];
+    const time = normalColor(dateTime.substring(TIME_START, TIME_END));
+    const id = normalColor(this.#worker);
+    const mark = markColor(' ' + tag.padEnd(TAG_LENGTH));
+    const msg = normalColor(message);
+    return `${time}  ${id}  ${mark}  ${msg}`;
+  }
+
+  formatFile(tag, indent, args) {
+    const dateTime = new Date().toISOString();
+    const message = this.format(tag, indent, args);
+    const msg = metautil.replace(message, '\n', LINE_SEPARATOR);
+    return `${dateTime} [${tag}] ${msg}`;
+  }
+
+  formatJson(tag, indent, args) {
+    const timestamp = new Date().toISOString();
+    const json = { timestamp, worker: this.#worker, tag, message: null };
+    let data = args.slice();
+    const head = data[0];
+    if (metautil.isError(head)) {
+      json.error = this.expandError(head);
+      data = data.slice(1);
+    } else if (typeof head === 'object') {
+      Object.assign(json, head);
+      data = data.slice(1);
+    }
+    json.message = util.format(...data);
+    return JSON.stringify(json);
+  }
+
+  normalizeStack(stack) {
+    if (!stack) return 'No stack trace to log';
+    let res = metautil.replace(stack, STACK_AT, '');
+    if (this.#home) res = metautil.replace(res, this.#home, '');
+    return res;
+  }
+
+  expandError(error) {
+    return {
+      message: error.message,
+      stack: this.normalizeStack(error.stack),
+      ...error,
+    };
+  }
+}
+
 class Console {
-  #write;
+  #logger;
   #groupIndent = 0;
   #counts = new Map();
   #times = new Map();
   #readline = readline;
 
-  constructor(write) {
-    this.#write = write;
+  constructor(logger) {
+    this.#logger = logger;
   }
 
   assert(assertion, ...args) {
     if (!assertion) {
       const noArgs = args.length === 0;
       const message = noArgs ? 'Assertion failed' : util.format(...args);
-      this.#write('error', this.#groupIndent, message);
+      this.#logger.write('error', this.#groupIndent, [message]);
     }
   }
 
@@ -105,7 +237,7 @@ class Console {
     let cnt = this.#counts.get(label) || 0;
     cnt++;
     this.#counts.set(label, cnt);
-    this.#write('debug', this.#groupIndent, `${label}: ${cnt}`);
+    this.#logger.write('debug', this.#groupIndent, [`${label}: ${cnt}`]);
   }
 
   countReset(label = 'default') {
@@ -113,33 +245,38 @@ class Console {
   }
 
   debug(...args) {
-    this.#write('debug', this.#groupIndent, ...args);
+    this.#logger.write('debug', this.#groupIndent, args);
+  }
+
+  dir(obj, options) {
+    const inspected = util.inspect(obj, options);
+    this.#logger.write('debug', this.#groupIndent, [inspected]);
   }
 
-  dir(...args) {
-    this.#write('debug', this.#groupIndent, ...args);
+  dirxml(...data) {
+    this.#logger.write('debug', this.#groupIndent, data);
   }
 
   trace(...args) {
     const msg = util.format(...args);
     const err = new Error(msg);
-    this.#write('debug', this.#groupIndent, `Trace${err.stack}`);
+    this.#logger.write('debug', this.#groupIndent, [`Trace${err.stack}`]);
   }
 
   info(...args) {
-    this.#write('info', this.#groupIndent, ...args);
+    this.#logger.write('info', this.#groupIndent, args);
   }
 
   log(...args) {
-    this.#write('log', this.#groupIndent, ...args);
+    this.#logger.write('log', this.#groupIndent, args);
   }
 
   warn(...args) {
-    this.#write('warn', this.#groupIndent, ...args);
+    this.#logger.write('warn', this.#groupIndent, args);
   }
 
   error(...args) {
-    this.#write('error', this.#groupIndent, ...args);
+    this.#logger.write('error', this.#groupIndent, args);
   }
 
   group(...args) {
@@ -156,8 +293,22 @@ class Console {
     this.#groupIndent -= INDENT;
   }
 
-  table(tabularData) {
-    this.#write('log', 0, JSON.stringify(tabularData));
+  table(tabularData, properties) {
+    const opts = { showHidden: false, depth: null, colors: false };
+    let data = tabularData;
+    if (properties) {
+      if (!Array.isArray(data)) data = [data];
+      data = data.map((item) => {
+        const record = {};
+        for (const prop of properties) {
+          if (Object.prototype.hasOwnProperty.call(item, prop)) {
+            record[prop] = item[prop];
+          }
+        }
+        return record;
+      });
+    }
+    this.#logger.write('log', 0, [util.inspect(data, opts)]);
   }
 
   time(label = 'default') {
@@ -172,132 +323,125 @@ class Console {
     this.#times.delete(label);
   }
 
-  timeLog(label, ...args) {
+  timeLog(label = 'default', ...data) {
     const startTime = this.#times.get(label);
     if (startTime === undefined) {
       const msg = `Warning: No such label '${label}'`;
-      this.#write('warn', this.#groupIndent, msg);
+      this.#logger.write('warn', this.#groupIndent, [msg]);
       return;
     }
-    this.#write('debug', this.#groupIndent, ...args);
+    const totalTime = process.hrtime(startTime);
+    const totalTimeMs = totalTime[0] * 1e3 + totalTime[1] / 1e6;
+    const message = data.length > 0 ? util.format(...data) : '';
+    const output = `${label}: ${totalTimeMs}ms${message ? ' ' + message : ''}`;
+    this.#logger.write('debug', this.#groupIndent, [output]);
   }
 }
 
-class Logger extends events.EventEmitter {
+class Logger extends EventEmitter {
+  active = false;
+  #worker = 'W0';
+  #createStream = fs.createWriteStream;
+  #options = null;
+  #keepDays = DEFAULT_KEEP_DAYS;
+  #stream = null;
+  #rotationTimer = null;
+  #file = '';
+  #fsEnabled = false;
+  #toFile = null;
+  #toStdout = null;
+  #buffer = null;
+  #formatter = null;
+
   constructor(options) {
     super();
-    const { workerId = 0, createStream = fs.createWriteStream } = options;
-    const { writeInterval, writeBuffer, keepDays, home, json } = options;
-    const { toFile = LOG_TYPES, toStdout = LOG_TYPES, crash } = options;
-    this.active = false;
-    this.path = options.path;
+    this.#options = options;
+    const { workerId, createStream, keepDays, home, crash, json } = options;
+    const { toFile = LOG_TAGS, toStdout = LOG_TAGS } = options;
     this.path = path.resolve(options.path);
-    this.workerId = `W${workerId}`;
-    this.createStream = createStream;
-    this.writeInterval = writeInterval || DEFAULT_WRITE_INTERVAL;
-    this.writeBuffer = writeBuffer || DEFAULT_BUFFER_SIZE;
-    this.keepDays = keepDays || DEFAULT_KEEP_DAYS;
     this.home = home ? path.resolve(home) : undefined;
-    this.json = Boolean(json);
-    this.stream = null;
-    this.reopenTimer = null;
-    this.flushTimer = null;
-    this.lock = false;
-    this.buffer = [];
-    this.bufferLength = 0;
-    this.file = '';
-    this.toFile = logTypes(toFile);
-    this.fsEnabled = toFile.length !== 0;
-    this.toStdout = logTypes(toStdout);
-    this.console = new Console((...args) => this.write(...args));
+    this.console = new Console(this);
+    if (workerId) this.#worker = `W${workerId}`;
+    if (toFile) this.#toFile = logTags(toFile);
+    if (toStdout) this.#toStdout = logTags(toStdout);
+    if (createStream) this.#createStream = createStream;
+    if (keepDays) this.#keepDays = keepDays;
     if (crash === 'flush') this.#setupCrashHandling();
+    this.#fsEnabled = toFile.length !== 0;
+    this.#buffer = null;
+    const formatterOptions = { json, worker: this.#worker, home: this.home };
+    this.#formatter = new Formatter(formatterOptions);
     return this.open();
   }
 
-  createLogDir() {
-    return new Promise((resolve, reject) => {
-      fs.access(this.path, (err) => {
-        if (!err) resolve();
-        fs.mkdir(this.path, (err) => {
-          if (!err || err.code === 'EEXIST') return void resolve();
-          const error = new Error(`Can not create directory: ${this.path}\n`);
-          this.emit('error', error);
-          reject();
-        });
-      });
-    });
+  static async create(options) {
+    return new Logger(options);
   }
 
   async open() {
     if (this.active) return this;
     this.active = true;
-    if (!this.fsEnabled) {
-      process.nextTick(() => this.emit('open'));
-      return this;
-    }
-    await this.createLogDir();
-    const fileName = metautil.nowDate() + '-' + this.workerId + '.log';
-    this.file = path.join(this.path, fileName);
+    if (!this.#fsEnabled) return this;
+    await this.#createDir();
+    const fileName = metautil.nowDate() + '-' + this.#worker + '.log';
+    this.#file = path.join(this.path, fileName);
     const nextReopen = getNextReopen();
-    this.reopenTimer = setTimeout(() => {
+    this.#rotationTimer = setTimeout(() => {
       this.once('close', () => {
         this.open();
       });
-      this.close().catch((err) => {
-        process.stdout.write(`${err.stack}\n`);
-        this.emit('error', err);
+      this.close().catch((error) => {
+        this.emit('error', error);
       });
     }, nextReopen);
-    if (this.keepDays) await this.rotate();
-    this.stream = this.createStream(this.file, { flags: 'a' });
-    this.flushTimer = setInterval(() => {
-      this.flush();
-    }, this.writeInterval);
-    this.stream.on('open', () => {
-      this.emit('open');
+    if (this.#keepDays) await this.rotate();
+    const stream = this.#createStream(this.#file, { flags: 'a' });
+    this.#stream = stream;
+    const { writeBuffer, flushInterval } = this.#options;
+    this.#buffer = new BufferedStream({ writeBuffer, stream, flushInterval });
+    stream.on('error', (error) => {
+      const errorMsg = `Can't open log file: ${this.#file}, ${error.message}`;
+      this.emit('error', new Error(errorMsg));
     });
-    this.stream.on('error', () => {
-      this.emit('error', new Error(`Can't open log file: ${this.file}`));
-    });
-    await events.once(this, 'open');
+    await EventEmitter.once(stream, 'open');
     return this;
   }
 
   async close() {
     if (!this.active) return Promise.resolve();
-    if (!this.fsEnabled) {
+    if (!this.#fsEnabled) {
       this.active = false;
       this.emit('close');
       return Promise.resolve();
     }
-    const { stream } = this;
-    if (!stream || stream.destroyed || stream.closed) {
-      return Promise.resolve();
-    }
+    const stream = this.#stream;
+    if (stream.destroyed || stream.closed) return Promise.resolve();
+    clearTimeout(this.#rotationTimer);
+    this.#rotationTimer = null;
     return new Promise((resolve, reject) => {
-      this.flush((err) => {
-        if (err) return void reject(err);
+      this.flush((error) => {
+        if (error) return void reject(error);
         this.active = false;
-        stream.end(() => {
-          clearInterval(this.flushTimer);
-          clearTimeout(this.reopenTimer);
-          this.flushTimer = null;
-          this.reopenTimer = null;
-          const fileName = this.file;
-          this.emit('close');
-          fs.stat(fileName, (err, stats) => {
-            if (!err && stats.size === 0) {
+        this.#buffer
+          .close()
+          .then(() => {
+            const fileName = this.#file;
+            this.emit('close');
+            fs.stat(fileName, (error, stats) => {
+              if (error || stats.size > 0) {
+                return void resolve();
+              }
               fsp.unlink(fileName).catch(() => {});
-            }
-            resolve();
-          });
-        });
+              resolve();
+            });
+          })
+          .catch(reject);
       });
     });
   }
 
   async rotate() {
-    if (!this.keepDays) return;
+    if (!this.#keepDays) return;
     const now = nowDays();
     const finish = [];
     try {
@@ -305,150 +449,85 @@ class Logger extends events.EventEmitter {
       for (const fileName of files) {
         if (metautil.fileExt(fileName) !== 'log') continue;
         const fileAge = now - nameToDays(fileName);
-        if (fileAge < this.keepDays) continue;
+        if (fileAge < this.#keepDays) continue;
         const filePath = path.join(this.path, fileName);
         const promise = fsp.unlink(filePath).catch(() => {});
         finish.push(promise);
       }
       await Promise.allSettled(finish);
-    } catch (err) {
-      process.stdout.write(`${err.stack}\n`);
-      this.emit('error', err);
+    } catch (error) {
+      process.stdout.write(`${error.stack}\n`);
+      this.emit('error', error);
     }
   }
 
-  format(type, indent, ...args) {
-    const normalize = type === 'error' || type === 'debug';
-    const s = `${' '.repeat(indent)}${util.format(...args)}`;
-    return normalize ? this.normalizeStack(s) : s;
-  }
-
-  formatPretty(type, indent, ...args) {
-    const dateTime = new Date().toISOString();
-    const message = this.format(type, indent, ...args);
-    const normalColor = TEXT_COLOR[type];
-    const markColor = TYPE_COLOR[type];
-    const time = normalColor(dateTime.substring(TIME_START, TIME_END));
-    const id = normalColor(this.workerId);
-    const mark = markColor(' ' + type.padEnd(TYPE_LENGTH));
-    const msg = normalColor(message);
-    return `${time}  ${id}  ${mark}  ${msg}`;
-  }
-
-  formatFile(type, indent, ...args) {
-    const dateTime = new Date().toISOString();
-    const message = this.format(type, indent, ...args);
-    const msg = metautil.replace(message, '\n', LINE_SEPARATOR);
-    return `${dateTime} [${type}] ${msg}`;
-  }
-
-  formatJson(type, indent, ...args) {
-    const log = {
-      timestamp: new Date().toISOString(),
-      workerId: this.workerId,
-      level: type,
-      message: null,
-    };
-    if (metautil.isError(args[0])) {
-      log.err = this.expandError(args[0]);
-      args = args.slice(1);
-    } else if (typeof args[0] === 'object') {
-      Object.assign(log, args[0]);
-      if (metautil.isError(log.err)) log.err = this.expandError(log.err);
-      if (metautil.isError(log.error)) log.error = this.expandError(log.error);
-      args = args.slice(1);
-    }
-    log.message = util.format(...args);
-    return JSON.stringify(log);
+  #createDir() {
+    return new Promise((resolve, reject) => {
+      fs.access(this.path, (error) => {
+        if (!error) resolve();
+        fs.mkdir(this.path, (error) => {
+          if (!error || error.code === 'EEXIST') {
+            return void resolve();
+          } else {
+            const error = new Error(`Can not create directory: ${this.path}`);
+            this.emit('error', error);
+            reject(error);
+          }
+        });
+      });
+    });
   }
 
-  write(type, indent, ...args) {
-    if (this.toStdout[type]) {
-      const line = this.json
-        ? this.formatJson(type, indent, ...args)
-        : this.formatPretty(type, indent, ...args);
+  write(tag, indent, args) {
+    if (this.#toStdout[tag]) {
+      const line = this.#options.json
+        ? this.#formatter.formatJson(tag, indent, args)
+        : this.#formatter.formatPretty(tag, indent, args);
       process.stdout.write(line + '\n');
     }
-    if (this.toFile[type]) {
-      const line = this.json
-        ? this.formatJson(type, indent, ...args)
-        : this.formatFile(type, indent, ...args);
+    if (this.#toFile[tag]) {
+      const line = this.#options.json
+        ? this.#formatter.formatJson(tag, indent, args)
+        : this.#formatter.formatFile(tag, indent, args);
       const buffer = Buffer.from(line + '\n');
-      this.buffer.push(buffer);
-      this.bufferLength += buffer.length;
-      if (this.bufferLength >= this.writeBuffer) this.flush();
+      this.#buffer.write(buffer);
     }
   }
 
   flush(callback) {
-    if (this.lock) {
-      if (callback) this.once('unlocked', callback);
-      return;
-    }
-    if (this.buffer.length === 0) {
-      if (callback) callback();
-      return;
-    }
     if (!this.active) {
-      const err = new Error('Cannot flush log buffer: logger is not active');
-      this.emit('error', err);
-      if (callback) callback(err);
+      if (callback) callback();
       return;
     }
-    if (!this.stream || this.stream.destroyed || this.stream.closed) {
-      const err = new Error('Cannot flush log buffer: stream is not available');
-      this.emit('error', err);
-      if (callback) callback(err);
+    if (!this.#buffer) {
+      if (callback) callback();
       return;
     }
-    this.lock = true;
-    const buffer = Buffer.concat(this.buffer);
-    this.buffer.length = 0;
-    this.bufferLength = 0;
-    this.stream.write(buffer, () => {
-      this.lock = false;
-      this.emit('unlocked');
-      if (callback) callback();
+    this.#buffer.flush((error) => {
+      if (error) this.emit('error', error);
+      if (callback) callback(error);
     });
   }
 
-  normalizeStack(stack) {
-    if (!stack) return 'no data to log';
-    let res = metautil.replace(stack, STACK_AT, '');
-    if (this.home) res = metautil.replace(res, this.home, '');
-    return res;
-  }
-
-  expandError(err) {
-    return {
-      message: err.message,
-      stack: this.normalizeStack(err.stack),
-      ...err,
-    };
-  }
-
   #setupCrashHandling() {
     const exitHandler = () => {
-      this.flush();
+      if (this.active) this.flush();
     };
     process.on('SIGTERM', exitHandler);
     process.on('SIGINT', exitHandler);
     process.on('SIGUSR1', exitHandler);
     process.on('SIGUSR2', exitHandler);
-    process.on('uncaughtException', (err) => {
-      this.write('error', 0, 'Uncaught Exception:', err);
-      this.flush();
-    });
-    process.on('unhandledRejection', (reason) => {
-      this.write('error', 0, 'Unhandled Rejection:', reason);
-      this.flush();
-    });
-    process.on('exit', () => {
-      this.flush();
-    });
+    process.on('uncaughtException', exitHandler);
+    process.on('unhandledRejection', exitHandler);
+    process.on('exit', exitHandler);
   }
 }
 
-const openLog = async (options) => new Logger(options);
-
-module.exports = { Logger, openLog };
+module.exports = {
+  Logger,
+  Console,
+  BufferedStream,
+  Formatter,
+  nowDays,
+  nameToDays,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metalog",
-  "version": "3.1.18",
+  "version": "4.0.1-prerelease",
   "author": "Timur Shemsedinov <timur.shemsedinov@gmail.com>",
   "description": "Logger for Metarhia",
   "license": "MIT",
@@ -56,8 +56,8 @@
     "metautil": "^5.3.0"
   },
   "devDependencies": {
-    "@types/node": "^24.3.0",
-    "eslint": "^9.34.0",
+    "@types/node": "^24.3.1",
+    "eslint": "^9.35.0",
     "eslint-config-metarhia": "^9.1.3",
     "prettier": "^3.6.2",
     "typescript": "^5.9.2"