[WIP] lib: added logger api in node core

benchmark/logger/basic-json.js

@@ -0,0 +1,174 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('node:fs');
+
+const bench = common.createBenchmark(main, {
+  n: [1e5],
+  scenario: [
+    'string-short',
+    'string-long',
+    'object-simple',
+    'object-nested',
+    'object-array',
+    'object-mixed',
+    'child-logger',
+    'disabled-level',
+    'error-object',
+  ],
+});
+
+function main({ n, scenario }) {
+  const { Logger, JSONConsumer } = require('node:logger');
+
+  const nullFd = fs.openSync('/dev/null', 'w');
+  const consumer = new JSONConsumer({ stream: nullFd, level: 'info' });
+  consumer.attach();
+
+  const logger = new Logger({ level: 'info' });
+
+  switch (scenario) {
+    case 'string-short': {
+      // Simple short string message
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        logger.info('hello');
+      }
+      bench.end(n);
+      break;
+    }
+
+    case 'string-long': {
+      // Long string message (100 chars)
+      const longMsg = 'This is a much longer log message that contains ' +
+        'more text to serialize and process during logging operations';
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        logger.info(longMsg);
+      }
+      bench.end(n);
+      break;
+    }
+
+    case 'object-simple': {
+      // Object with msg and a few string fields
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        logger.info({
+          msg: 'user action',
+          userId: 'user-123',
+          action: 'login',
+        });
+      }
+      bench.end(n);
+      break;
+    }
+
+    case 'object-nested': {
+      // Object with nested structure
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        logger.info({
+          msg: 'request completed',
+          request: {
+            method: 'POST',
+            path: '/api/users',
+            headers: {
+              'content-type': 'application/json',
+              'user-agent': 'Mozilla/5.0',
+            },
+          },
+          response: {
+            statusCode: 200,
+            body: { success: true },
+          },
+        });
+      }
+      bench.end(n);
+      break;
+    }
+
+    case 'object-array': {
+      // Object with array fields
+      const tags = ['web', 'api', 'auth', 'production'];
+      const ids = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        logger.info({
+          msg: 'batch operation',
+          tags,
+          processedIds: ids,
+          results: ['success', 'success', 'failed', 'success'],
+        });
+      }
+      bench.end(n);
+      break;
+    }
+
+    case 'object-mixed': {
+      // Mixed types: strings, numbers, booleans, null
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        logger.info({
+          msg: 'mixed data',
+          stringField: 'value',
+          numberField: 42,
+          floatField: 3.14159,
+          booleanField: true,
+          nullField: null,
+          timestamp: 1704067200000,
+        });
+      }
+      bench.end(n);
+      break;
+    }
+
+    case 'child-logger': {
+      // Child logger with pre-bound context
+      const childLogger = logger.child({
+        service: 'api',
+        version: '1.0.0',
+        env: 'production',
+      });
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        childLogger.info({
+          msg: 'request',
+          requestId: 'req-123',
+          duration: 150,
+        });
+      }
+      bench.end(n);
+      break;
+    }
+
+    case 'disabled-level': {
+      // Logging at disabled level (debug when level is info)
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        logger.debug('this will be skipped');
+      }
+      bench.end(n);
+      break;
+    }
+
+    case 'error-object': {
+      // Logging with Error object
+      const error = new Error('Something went wrong');
+      error.code = 'ERR_SOMETHING';
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        logger.error({
+          msg: 'operation failed',
+          err: error,
+          operation: 'database-query',
+        });
+      }
+      bench.end(n);
+      break;
+    }
+  }
+
+  consumer.flushSync();
+  fs.closeSync(nullFd);
+}

benchmark/logger/vs-pino.js

@@ -0,0 +1,146 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('node:fs');
+
+const bench = common.createBenchmark(main, {
+  n: [1e5],
+  logger: ['node-logger', 'pino'],
+  scenario: ['simple', 'child', 'disabled', 'fields'],
+});
+
+function main({ n, logger, scenario }) {
+  const nullFd = fs.openSync('/dev/null', 'w');
+  let testLogger;
+  let consumer;
+
+  if (logger === 'node-logger') {
+    const { Logger, JSONConsumer } = require('node:logger');
+
+    switch (scenario) {
+      case 'simple': {
+        consumer = new JSONConsumer({ stream: nullFd, level: 'info' });
+        consumer.attach();
+        testLogger = new Logger({ level: 'info' });
+
+        bench.start();
+        for (let i = 0; i < n; i++) {
+          testLogger.info('benchmark test message');
+        }
+        bench.end(n);
+        break;
+      }
+
+      case 'child': {
+        consumer = new JSONConsumer({ stream: nullFd, level: 'info' });
+        consumer.attach();
+        const baseLogger = new Logger({ level: 'info' });
+        testLogger = baseLogger.child({ requestId: 'req-123', userId: 456 });
+
+        bench.start();
+        for (let i = 0; i < n; i++) {
+          testLogger.info('benchmark test message');
+        }
+        bench.end(n);
+        break;
+      }
+
+      case 'disabled': {
+        consumer = new JSONConsumer({ stream: nullFd, level: 'warn' });
+        consumer.attach();
+        testLogger = new Logger({ level: 'warn' });
+
+        bench.start();
+        for (let i = 0; i < n; i++) {
+          testLogger.debug('benchmark test message');
+        }
+        bench.end(n);
+        break;
+      }
+
+      case 'fields': {
+        consumer = new JSONConsumer({ stream: nullFd, level: 'info' });
+        consumer.attach();
+        testLogger = new Logger({ level: 'info' });
+
+        bench.start();
+        for (let i = 0; i < n; i++) {
+          testLogger.info('benchmark test message', {
+            field1: 'value1',
+            field2: 'value2',
+            field3: 'value3',
+            field4: 'value4',
+            field5: 'value5',
+          });
+        }
+        bench.end(n);
+        break;
+      }
+    }
+
+    if (consumer) {
+      consumer.flushSync();
+    }
+    fs.closeSync(nullFd);
+
+  } else if (logger === 'pino') {
+    const pino = require('pino');
+    const destination = pino.destination({ dest: nullFd, sync: false });
+
+    switch (scenario) {
+      case 'simple': {
+        testLogger = pino({ level: 'info' }, destination);
+
+        bench.start();
+        for (let i = 0; i < n; i++) {
+          testLogger.info('benchmark test message');
+        }
+        bench.end(n);
+        break;
+      }
+
+      case 'child': {
+        const baseLogger = pino({ level: 'info' }, destination);
+        testLogger = baseLogger.child({ requestId: 'req-123', userId: 456 });
+
+        bench.start();
+        for (let i = 0; i < n; i++) {
+          testLogger.info('benchmark test message');
+        }
+        bench.end(n);
+        break;
+      }
+
+      case 'disabled': {
+        testLogger = pino({ level: 'warn' }, destination);
+
+        bench.start();
+        for (let i = 0; i < n; i++) {
+          testLogger.debug('benchmark test message');
+        }
+        bench.end(n);
+        break;
+      }
+
+      case 'fields': {
+        testLogger = pino({ level: 'info' }, destination);
+
+        bench.start();
+        for (let i = 0; i < n; i++) {
+          testLogger.info({
+            msg: 'benchmark test message',
+            field1: 'value1',
+            field2: 'value2',
+            field3: 'value3',
+            field4: 'value4',
+            field5: 'value5',
+          });
+        }
+        bench.end(n);
+        break;
+      }
+    }
+
+    destination.flushSync();
+  }
+}

doc/api/cli.md

@@ -1205,6 +1205,17 @@ Specify the `module` containing exported [asynchronous module customization hook
 
 This feature requires `--allow-worker` if used with the [Permission Model][].
 
+### `--experimental-logger`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Enable the experimental `node:logger` module for structured logging.
+See the [Logger][] documentation for more details.
+
 ### `--experimental-network-inspection`
 
 <!-- YAML
@@ -3594,6 +3605,7 @@ one is included in the list below.
 * `--experimental-import-meta-resolve`
 * `--experimental-json-modules`
 * `--experimental-loader`
+* `--experimental-logger`
 * `--experimental-modules`
 * `--experimental-print-required-tla`
 * `--experimental-quic`
@@ -4177,6 +4189,7 @@ node --stack-trace-limit=12 -p -e "Error.stackTraceLimit" # prints 12
 [ExperimentalWarning: `vm.measureMemory` is an experimental feature]: vm.md#vmmeasurememoryoptions
 [File System Permissions]: permissions.md#file-system-permissions
 [Loading ECMAScript modules using `require()`]: modules.md#loading-ecmascript-modules-using-require
+[Logger]: logger.md
 [Module resolution and loading]: packages.md#module-resolution-and-loading
 [Navigator API]: globals.md#navigator
 [Node.js issue tracker]: https://github.com/nodejs/node/issues

doc/api/index.md

@@ -65,6 +65,7 @@
 * [UDP/datagram](dgram.md)
 * [URL](url.md)
 * [Utilities](util.md)
+* [Logger](logger.md)
 * [V8](v8.md)
 * [VM](vm.md)
 * [WASI](wasi.md)