From 0e92441d2f2b35de8854fa47ad8fd7dae9bf404d Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sat, 3 Oct 2026 01:40:48 +0000
Subject: [PATCH 1/2] stream: fix Utf8Stream flush handling

Fix several issues with `Utf8Stream` flushing:

* `flush()` now writes buffered data regardless of `minLength`
  and invokes the callback only after pending writes complete,
  including when `minLength` is zero and a write is in flight.
* Multiple concurrent `flush()` calls are tracked correctly and
  `end()` waits for pending flushes before closing.
* `flushSync()` throws `ERR_INVALID_STATE` if called while an
  asynchronous write is in progress instead of corrupting output.
* Periodic flushes no longer stack up while a flush is pending.
* `fsync` is skipped for stdout/stderr file descriptors.
* `reopen()`, `end()` and `destroy()` behave correctly when the
  stream is destroyed while still opening.

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode
---
 doc/api/fs.md                                 |   7 +-
 lib/internal/streams/fast-utf8-stream.js      | 167 +++++++++++++----
 .../test-fastutf8stream-flush-sync.js         |  29 ++-
 test/parallel/test-fastutf8stream-flush.js    | 168 ++++++++++++++++++
 .../test-fastutf8stream-periodicflush.js      |  52 ++++++
 5 files changed, 382 insertions(+), 41 deletions(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index d6eb4208ef0a..4528f7a63e2f 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -8563,12 +8563,13 @@ Close the stream gracefully, flushing the internal buffer before closing.
 * `callback` {Function}
   * `err` {Error|null} An error if the flush failed, otherwise `null`.
 
-Writes the current buffer to the file if a write was not in progress. Do
-nothing if `minLength` is zero or if it is already writing.
+Writes the current buffer to the file. The callback is invoked after pending
+writes complete.
 
 #### `utf8Stream.flushSync()`
 
-Flushes the buffered data synchronously. This is a costly operation.
+Flushes the buffered data synchronously. This is a costly operation. An
+`ERR_INVALID_STATE` error is thrown if the stream is currently writing.
 
 #### `utf8Stream.fsync`
 
diff --git a/lib/internal/streams/fast-utf8-stream.js b/lib/internal/streams/fast-utf8-stream.js
index a11fbf3bbc0e..1a0266fa5738 100644
--- a/lib/internal/streams/fast-utf8-stream.js
+++ b/lib/internal/streams/fast-utf8-stream.js
@@ -7,6 +7,7 @@
 const {
   ArrayPrototypePush,
   MathMax,
+  Symbol,
   SymbolDispose,
 } = primordials;
 
@@ -58,6 +59,7 @@ const kMaxWrite = 16 * 1024;
 const kContentModeBuffer = 'buffer';
 const kContentModeUtf8 = 'utf8';
 const kNullPrototype = { __proto__: null };
+const kFlush = Symbol('kFlush');
 
 // Utf8Stream is a port of the original SonicBoom module
 // (https://github.com/pinojs/sonic-boom) that provides a fast and efficient
@@ -71,7 +73,9 @@ class Utf8Stream extends EventEmitter {
   #ending = false;
   #reopening = false;
   #asyncDrainScheduled = false;
-  #flushPending = false;
+  #flushPending = 0;
+  #flushInProgress = 0;
+  #emittingFlush = false;
   #hwm = 16387; // 16 KB
   #file = null;
   #destroyed = false;
@@ -228,7 +232,11 @@ class Utf8Stream extends EventEmitter {
     });
 
     if (this.#periodicFlush !== 0) {
-      this.#periodicFlushTimer = setInterval(() => this.flush(null), this.#periodicFlush);
+      this.#periodicFlushTimer = setInterval(() => {
+        if (this.#flushPending === 0 && this.#flushInProgress === 0) {
+          this.flush();
+        }
+      }, this.#periodicFlush);
       this.#periodicFlushTimer.unref();
     }
   }
@@ -263,7 +271,9 @@ class Utf8Stream extends EventEmitter {
     }
 
     if (this.#opening) {
-      this.once('ready', () => this.reopen(file));
+      this.once('ready', () => {
+        if (!this.#destroyed) this.reopen(file);
+      });
       return;
     }
 
@@ -306,7 +316,7 @@ class Utf8Stream extends EventEmitter {
 
     if (this.#opening) {
       this.once('ready', () => {
-        this.end();
+        if (!this.#destroyed) this.end();
       });
       return;
     }
@@ -324,7 +334,7 @@ class Utf8Stream extends EventEmitter {
     if (this.#len > 0 && this.#fd >= 0) {
       this.#actualWrite();
     } else {
-      this.#actualClose();
+      this.#finishEnding();
     }
   }
 
@@ -332,7 +342,11 @@ class Utf8Stream extends EventEmitter {
     if (this.#destroyed) {
       return;
     }
+    const opening = this.#opening;
     this.#actualClose();
+    if (opening && this.#flushPending > 0) {
+      this.emit('error', new ERR_INVALID_STATE('Utf8Stream is destroyed'));
+    }
   }
 
   /** @type {number} */
@@ -426,6 +440,18 @@ class Utf8Stream extends EventEmitter {
       }
     }
 
+    if (this.#destroyed) {
+      this.#writing = false;
+      if (this.#flushPending > 0) {
+        if (this.#len === 0) {
+          this.#scheduleDrain();
+        } else {
+          this.emit('error', new ERR_INVALID_STATE('Utf8Stream is destroyed'));
+        }
+      }
+      return;
+    }
+
     if (this.#fsync) {
       this.#fs.fsyncSync(this.#fd);
     }
@@ -435,25 +461,19 @@ class Utf8Stream extends EventEmitter {
       this.#writing = false;
       this.#reopening = false;
       this.reopen();
-    } else if (len > this.#minLength) {
+    } else if (len > 0 &&
+               (len > this.#minLength || this.#flushPending)) {
       this.#actualWrite();
     } else if (this.#ending) {
       if (len > 0) {
         this.#actualWrite();
       } else {
         this.#writing = false;
-        this.#actualClose();
+        this.#finishEnding();
       }
     } else {
       this.#writing = false;
-      if (this.#sync) {
-        if (!this.#asyncDrainScheduled) {
-          this.#asyncDrainScheduled = true;
-          process.nextTick(() => this.#emitDrain());
-        }
-      } else {
-        this.emit('drain');
-      }
+      this.#scheduleDrain();
     }
   }
 
@@ -502,12 +522,13 @@ class Utf8Stream extends EventEmitter {
       }
 
       // start
-      if ((!this.#writing && this.#len > this.#minLength) || this.#flushPending) {
+      if (!this.#writing &&
+          (this.#len > this.#minLength || this.#flushPending)) {
         this.#actualWrite();
       } else if (reopening && !this.#writing) {
         // Do not emit 'drain' if a 'ready' listener started a write:
         // #release() will emit the real 'drain' when that write completes.
-        process.nextTick(() => this.emit('drain'));
+        process.nextTick(() => this.#emitDrain());
       }
     };
 
@@ -533,16 +554,59 @@ class Utf8Stream extends EventEmitter {
     }
   }
 
+  #scheduleDrain() {
+    if (this.#sync) {
+      if (!this.#asyncDrainScheduled) {
+        this.#asyncDrainScheduled = true;
+        process.nextTick(() => this.#emitDrain());
+      }
+    } else {
+      this.#emitDrain();
+    }
+  }
+
   #emitDrain() {
+    this.#asyncDrainScheduled = false;
+    if (this.#writing) return;
+    this.#emitFlush();
+    if (this.#writing || this.#destroyed) return;
     const hasListeners = this.listenerCount('drain') > 0;
     if (!hasListeners) return;
-    this.#asyncDrainScheduled = false;
     this.emit('drain');
   }
 
+  #finishEnding() {
+    if (!this.#ending || this.#writing || this.#destroyed) return;
+    if (this.#len > 0) {
+      this.#actualWrite();
+      return;
+    }
+    if (this.#flushPending > 0) this.#emitFlush();
+    if (this.#flushPending === 0 && this.#flushInProgress === 0 &&
+        !this.#writing && this.#len === 0) {
+      this.#actualClose();
+    }
+  }
+
+  #emitFlush() {
+    if (this.#emittingFlush) return;
+    this.#emittingFlush = true;
+    try {
+      this.emit(kFlush);
+    } finally {
+      this.#emittingFlush = false;
+    }
+  }
+
   #actualClose() {
+    if (this.#destroyed) return;
+
     if (this.#fd === -1) {
-      this.once('ready', () => this.#actualClose());
+      this.#destroyed = true;
+      this.once('ready', () => {
+        this.#destroyed = false;
+        this.#actualClose();
+      });
       return;
     }
 
@@ -627,7 +691,11 @@ class Utf8Stream extends EventEmitter {
       throw new ERR_INVALID_STATE('Invalid file descriptor');
     }
 
-    if (!this.#writing && this.#writingBuf.length > 0) {
+    if (this.#writing) {
+      throw new ERR_INVALID_STATE('Cannot flush while a write is in progress');
+    }
+
+    if (this.#writingBuf.length > 0) {
       this.#bufs.unshift([this.#writingBuf]);
       this.#writingBuf = kEmptyBuffer;
     }
@@ -665,7 +733,11 @@ class Utf8Stream extends EventEmitter {
       throw new ERR_INVALID_STATE('Invalid file descriptor');
     }
 
-    if (!this.#writing && this.#writingBuf.length > 0) {
+    if (this.#writing) {
+      throw new ERR_INVALID_STATE('Cannot flush while a write is in progress');
+    }
+
+    if (this.#writingBuf.length > 0) {
       this.#bufs.unshift(this.#writingBuf);
       this.#writingBuf = '';
     }
@@ -701,37 +773,58 @@ class Utf8Stream extends EventEmitter {
   }
 
   #callFlushCallbackOnDrain(cb) {
-    this.#flushPending = true;
+    this.#flushPending++;
+    let waiting = true;
+    let completed = false;
+    let flushing = false;
+    const stopWaiting = () => {
+      if (!waiting) return false;
+      waiting = false;
+      this.off(kFlush, onDrain);
+      this.off('error', onError);
+      return true;
+    };
+    const complete = (err, finish = true) => {
+      if (completed) return;
+      completed = true;
+      if (flushing) this.#flushInProgress--;
+      try {
+        cb(err);
+      } finally {
+        if (finish) this.#finishEnding();
+      }
+    };
     const onDrain = () => {
+      if (!stopWaiting()) return;
+      this.#flushPending--;
+      this.#flushInProgress++;
+      flushing = true;
       // Only if _fsync is false to avoid double fsync
-      if (!this.#fsync && !this.#destroyed) {
+      if (!this.#fsync && !this.#destroyed &&
+          this.#fd !== 1 && this.#fd !== 2) {
         try {
           this.#fs.fsync(this.#fd, (err) => {
-            this.#flushPending = false;
             // If the fd is closed, we ignore the error.
             if (err?.code === 'EBADF') {
-              cb();
+              complete();
               return;
             }
-            cb(err);
+            complete(err);
           });
         } catch (err) {
-          this.#flushPending = false;
-          cb(err);
+          complete(err);
         }
       } else {
-        this.#flushPending = false;
-        cb();
+        complete();
       }
-      this.off('error', onError);
     };
     const onError = (err) => {
-      this.#flushPending = false;
-      cb(err);
-      this.off('drain', onDrain);
+      if (!stopWaiting()) return;
+      this.#flushPending--;
+      complete(err, false);
     };
 
-    this.once('drain', onDrain);
+    this.once(kFlush, onDrain);
     this.once('error', onError);
   }
 
@@ -748,7 +841,7 @@ class Utf8Stream extends EventEmitter {
       throw error;
     }
 
-    if (this.#minLength <= 0) {
+    if (this.#minLength <= 0 && !this.#writing && this.#len === 0) {
       cb?.();
       return;
     }
@@ -782,7 +875,7 @@ class Utf8Stream extends EventEmitter {
       throw error;
     }
 
-    if (this.#minLength <= 0) {
+    if (this.#minLength <= 0 && !this.#writing && this.#len === 0) {
       cb?.();
       return;
     }
diff --git a/test/parallel/test-fastutf8stream-flush-sync.js b/test/parallel/test-fastutf8stream-flush-sync.js
index a48dac8e08e9..8630cf1ff94b 100644
--- a/test/parallel/test-fastutf8stream-flush-sync.js
+++ b/test/parallel/test-fastutf8stream-flush-sync.js
@@ -67,7 +67,7 @@ function runTests(sync) {
   const stream = new Utf8Stream({
     fd,
     sync: false,
-    minLength: 0,
+    minLength: 1000,
     fs: fsOverride,
   });
 
@@ -85,6 +85,33 @@ function runTests(sync) {
   }));
 }
 
+for (const contentMode of ['utf8', 'buffer']) {
+  const dest = getTempFile();
+  const fd = openSync(dest, 'w');
+  const stream = new Utf8Stream({
+    contentMode,
+    fd,
+    minLength: 0,
+    sync: false,
+  });
+  const text = `${contentMode} asynchronous write\n`;
+  const data = contentMode === 'buffer' ? Buffer.from(text) : text;
+
+  stream.on('ready', common.mustCall(() => {
+    assert.ok(stream.write(data));
+    assert.throws(
+      () => stream.flushSync(),
+      { code: 'ERR_INVALID_STATE' },
+    );
+    stream.flush(common.mustSucceed(() => {
+      stream.end();
+      readFile(dest, 'utf8', common.mustSucceed((contents) => {
+        assert.strictEqual(contents, text);
+      }));
+    }));
+  }));
+}
+
 {
   const dest = getTempFile();
   const fd = openSync(dest, 'w');
diff --git a/test/parallel/test-fastutf8stream-flush.js b/test/parallel/test-fastutf8stream-flush.js
index 195d5e83c9c7..c36b0d3554e5 100644
--- a/test/parallel/test-fastutf8stream-flush.js
+++ b/test/parallel/test-fastutf8stream-flush.js
@@ -4,6 +4,7 @@ const common = require('../common');
 const tmpdir = require('../common/tmpdir');
 const assert = require('node:assert');
 const {
+  open,
   openSync,
   readFile,
   writeFileSync,
@@ -25,6 +26,173 @@ function getTempFile() {
 runTests(false);
 runTests(true);
 
+{
+  const dest = getTempFile();
+  const fd = openSync(dest, 'w');
+  const stream = new Utf8Stream({ fd, minLength: 10, sync: false });
+  let flushed = false;
+
+  assert.ok(stream.write('asynchronous flush\n'));
+  assert.ok(stream.write('queued\n'));
+  assert.strictEqual(stream.writing, true);
+  stream.flush(common.mustSucceed(() => {
+    flushed = true;
+    assert.strictEqual(stream.writing, false);
+    readFile(dest, 'utf8', common.mustSucceed((data) => {
+      assert.strictEqual(data, 'asynchronous flush\nqueued\n');
+      stream.end();
+    }));
+  }));
+  assert.strictEqual(flushed, false);
+}
+
+{
+  const dest = getTempFile();
+  const fd = openSync(dest, 'w');
+  const stream = new Utf8Stream({ fd, minLength: 0, sync: false });
+
+  assert.ok(stream.write('flush before end\n'));
+  stream.flush(common.mustSucceed());
+  stream.on('finish', common.mustCall(() => {
+    readFile(dest, 'utf8', common.mustSucceed((data) => {
+      assert.strictEqual(data, 'flush before end\n');
+    }));
+  }));
+  stream.end();
+}
+
+{
+  const dest = getTempFile();
+  const fd = openSync(dest, 'w');
+  const writeError = new Error('write failed');
+  const stream = new Utf8Stream({
+    fd,
+    minLength: 0,
+    sync: false,
+    fs: {
+      write: common.mustCall((_fd, _data, _encoding, callback) => {
+        process.nextTick(callback, writeError);
+      }),
+    },
+  });
+
+  stream.on('error', common.mustCall((error) => {
+    assert.strictEqual(error, writeError);
+  }));
+  assert.ok(stream.write('failed write before end\n'));
+  stream.flush(common.mustCall((error) => {
+    assert.strictEqual(error, writeError);
+  }));
+  stream.end();
+}
+
+{
+  const dest = getTempFile();
+  const fd = openSync(dest, 'w');
+  let fsyncCalls = 0;
+  const stream = new Utf8Stream({
+    fd,
+    minLength: 10,
+    sync: false,
+    fs: {
+      fsync: common.mustCall((_fd, callback) => {
+        fsyncCalls++;
+        if (fsyncCalls === 1) {
+          assert.ok(stream.write('late\n'));
+        }
+        process.nextTick(callback);
+      }, 2),
+    },
+  });
+
+  assert.ok(stream.write('initial write\n'));
+  stream.flush(common.mustSucceed());
+  stream.on('finish', common.mustCall(() => {
+    readFile(dest, 'utf8', common.mustSucceed((data) => {
+      assert.strictEqual(data, 'initial write\nlate\n');
+    }));
+  }));
+  stream.end();
+}
+
+{
+  const dest = getTempFile();
+  const fd = openSync(dest, 'w');
+  const flushError = new Error('flush failed');
+  let fsyncCalls = 0;
+  const stream = new Utf8Stream({
+    fd,
+    minLength: 0,
+    sync: false,
+    fs: {
+      fsync: common.mustCall((_fd, callback) => {
+        fsyncCalls++;
+        process.nextTick(callback, fsyncCalls === 1 ? flushError : null);
+      }, 2),
+    },
+  });
+
+  assert.ok(stream.write('failed flush before end\n'));
+  stream.flush(common.mustCall((error) => {
+    assert.strictEqual(error, flushError);
+  }));
+  stream.on('close', common.mustCall());
+  stream.end();
+}
+
+{
+  const dest = getTempFile();
+  const stream = new Utf8Stream({
+    dest,
+    fs: {
+      open(...args) {
+        setImmediate(() => open(...args));
+      },
+    },
+  });
+
+  stream.flush(common.mustSucceed());
+  stream.on('close', common.mustCall());
+  stream.end();
+}
+
+{
+  const dest = getTempFile();
+  const stream = new Utf8Stream({
+    dest,
+    fs: {
+      open(...args) {
+        setImmediate(() => open(...args));
+      },
+    },
+  });
+
+  stream.flush(common.mustCall((error) => {
+    assert.strictEqual(error?.code, 'ERR_INVALID_STATE');
+  }));
+  stream.on('close', common.mustCall());
+  stream.destroy();
+  stream.flush(common.mustCall((error) => {
+    assert.strictEqual(error?.code, 'ERR_INVALID_STATE');
+  }));
+}
+
+{
+  const dest = getTempFile();
+  const stream = new Utf8Stream({
+    dest,
+    fs: {
+      open(...args) {
+        setImmediate(() => open(...args));
+      },
+    },
+  });
+
+  stream.on('close', common.mustCall());
+  stream.end();
+  stream.destroy();
+}
+
 function runTests(sync) {
   {
     const dest = getTempFile();
diff --git a/test/parallel/test-fastutf8stream-periodicflush.js b/test/parallel/test-fastutf8stream-periodicflush.js
index f7029a213502..4889fa8b19eb 100644
--- a/test/parallel/test-fastutf8stream-periodicflush.js
+++ b/test/parallel/test-fastutf8stream-periodicflush.js
@@ -75,4 +75,56 @@ function runTests(sync) {
 
     stream.destroy();
   }
+
+  {
+    const dest = getTempFile();
+    const fd = openSync(dest, 'w');
+    const stream = new Utf8Stream({
+      fd,
+      sync,
+      minLength: 5000,
+      periodicFlush: common.platformTimeout(10),
+    });
+    const timeout = setTimeout(
+      common.mustNotCall('periodic flush did not complete'),
+      common.platformTimeout(1000),
+    );
+
+    stream.once('drain', common.mustCall(() => {
+      clearTimeout(timeout);
+      stream.destroy();
+      readFile(dest, 'utf8', common.mustSucceed((data) => {
+        assert.strictEqual(data, 'periodic flush\n');
+      }));
+    }));
+    assert.ok(stream.write('periodic flush\n'));
+  }
+
+  if (!sync) {
+    const dest = getTempFile();
+    const fd = openSync(dest, 'w');
+    let fsyncCalls = 0;
+    const stream = new Utf8Stream({
+      fd,
+      minLength: 5000,
+      periodicFlush: common.platformTimeout(10),
+      fs: {
+        fsync: common.mustCall((_fd, callback) => {
+          fsyncCalls++;
+          if (fsyncCalls === 1) {
+            setTimeout(common.mustCall(() => {
+              assert.strictEqual(fsyncCalls, 1);
+              stream.destroy();
+              callback();
+            }), common.platformTimeout(50));
+          } else {
+            process.nextTick(callback);
+          }
+        }, 2),
+      },
+    });
+
+    stream.on('close', common.mustCall());
+    assert.ok(stream.write('slow fsync\n'));
+  }
 }

From 59cfdd3cd4e91b6d6357e9b0954856ccfcc029fe Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sun, 6 Sep 2026 06:42:45 +0000
Subject: [PATCH 2/2] lib: implement node:logger

A simpler attempt to add a structured logging API.

Uses a provider model similar to VFS.

This implements two providers out of the box,
ConsoleProvider and ReadableProvider. ConsoleProvider
is the default and uses Utf8Stream to emit to either
stdout or stderr.

```js
const { create } = require('node:logger');
const logger = create(); // default logger to console
logger.info('foo');

// ...
const als = new AsyncLocalStorage();
const logger2 = create(new ConsoleProvider({ pid: true }), {
  name: 'foo',
  bindings: {
    'abc': 'included in every log line',
    'xyz': als,  // current als.getStore() included in
                 // every log line
  }
});
logger2.info('foo', { baz: 1 });
```

The `Logger` keeps things as simple as possible, leaving
actual handling of the log events to the providers, which
can be fully customized. Easy to adapt to other loggers
like pino or extend capabilities without directly touching
the facade.

Signed-off-by: James M Snell <jasnell@gmail.com>
Assisted-by: Opencode
---
 benchmark/logger/console-provider.js          |   45 +
 benchmark/logger/creation.js                  |   34 +
 benchmark/logger/disabled.js                  |   36 +
 benchmark/logger/enabled.js                   |   50 +
 benchmark/logger/request.js                   |   43 +
 doc/api/cli.md                                |   12 +
 doc/api/index.md                              |    1 +
 doc/api/logger.md                             |  624 +++++++
 doc/api/process.md                            |   15 +
 doc/node.1                                    |    5 +
 lib/internal/bootstrap/realm.js               |    2 +
 lib/internal/process/pre_execution.js         |   10 +
 lib/logger.js                                 | 1510 +++++++++++++++++
 src/node_builtins.cc                          |    1 +
 src/node_options.cc                           |    4 +
 src/node_options.h                            |    1 +
 test/benchmark/test-benchmark-logger.js       |    7 +
 .../test-module-hooks-builtin-require.js      |    3 +-
 .../test-module-hooks-load-builtin-require.js |    3 +-
 ...t-logger-console-provider-serialization.js |  192 +++
 test/parallel/test-logger-console-provider.js |  278 +++
 .../test-logger-diagnostics-provider.js       |   83 +
 test/parallel/test-logger-level-dispatch.js   |  327 ++++
 test/parallel/test-logger.js                  |  467 +++++
 .../test-module-builtin-experimental.js       |    1 +
 25 files changed, 3752 insertions(+), 2 deletions(-)
 create mode 100644 benchmark/logger/console-provider.js
 create mode 100644 benchmark/logger/creation.js
 create mode 100644 benchmark/logger/disabled.js
 create mode 100644 benchmark/logger/enabled.js
 create mode 100644 benchmark/logger/request.js
 create mode 100644 doc/api/logger.md
 create mode 100644 lib/logger.js
 create mode 100644 test/benchmark/test-benchmark-logger.js
 create mode 100644 test/parallel/test-logger-console-provider-serialization.js
 create mode 100644 test/parallel/test-logger-console-provider.js
 create mode 100644 test/parallel/test-logger-diagnostics-provider.js
 create mode 100644 test/parallel/test-logger-level-dispatch.js
 create mode 100644 test/parallel/test-logger.js

diff --git a/benchmark/logger/console-provider.js b/benchmark/logger/console-provider.js
new file mode 100644
index 000000000000..499c17048589
--- /dev/null
+++ b/benchmark/logger/console-provider.js
@@ -0,0 +1,45 @@
+'use strict';
+
+// End-to-end cost of logging through ConsoleProvider with the default JSON
+// serializer. The provider's stream write() is replaced to avoid I/O latency.
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [5e5],
+  variant: ['json', 'flatten-pid', 'error'],
+}, {
+  flags: ['--experimental-logger', '--no-warnings'],
+});
+
+function main({ n, variant }) {
+  const { ConsoleProvider, create } = require('node:logger');
+
+  const provider = new ConsoleProvider({
+    flatten: variant === 'flatten-pid',
+    pid: variant === 'flatten-pid',
+  });
+  let bytes = 0;
+  provider.stream.write = (data) => {
+    bytes += data.length;
+    return true;
+  };
+  const logger = create(provider, {
+    name: 'bench',
+    bindings: { service: 'api' },
+  });
+
+  if (variant === 'error') {
+    const err = new Error('boom');
+    err.code = 'E_BOOM';
+    bench.start();
+    for (let i = 0; i < n; i++) logger.error('failed', { err });
+    bench.end(n);
+  } else {
+    bench.start();
+    for (let i = 0; i < n; i++) logger.info('hello', { i, user: 'x' });
+    bench.end(n);
+  }
+
+  if (bytes === 0) throw new Error('nothing was serialized');
+}
diff --git a/benchmark/logger/creation.js b/benchmark/logger/creation.js
new file mode 100644
index 000000000000..8823778c2db4
--- /dev/null
+++ b/benchmark/logger/creation.js
@@ -0,0 +1,34 @@
+'use strict';
+
+// Cost of creating loggers and child loggers.
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  type: ['create', 'child'],
+}, {
+  flags: ['--experimental-logger', '--no-warnings'],
+});
+
+function main({ n, type }) {
+  const { ConsoleProvider, create } = require('node:logger');
+
+  const provider = new ConsoleProvider();
+  const parent = create(provider, { name: 'bench' });
+  const loggers = new Array(1024);
+
+  if (type === 'child') {
+    bench.start();
+    for (let i = 0; i < n; i++) {
+      loggers[i & 1023] = parent.child({ requestId: i });
+    }
+    bench.end(n);
+  } else {
+    bench.start();
+    for (let i = 0; i < n; i++) {
+      loggers[i & 1023] = create(provider, { name: 'bench' });
+    }
+    bench.end(n);
+  }
+}
diff --git a/benchmark/logger/disabled.js b/benchmark/logger/disabled.js
new file mode 100644
index 000000000000..db07a3a0606c
--- /dev/null
+++ b/benchmark/logger/disabled.js
@@ -0,0 +1,36 @@
+'use strict';
+
+// Calls to level methods for a level the provider has disabled.
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [1e8],
+  provider: ['console', 'custom'],
+  attributes: ['none', 'object'],
+  child: [0, 1],
+}, {
+  flags: ['--experimental-logger', '--no-warnings'],
+});
+
+function main({ n, provider, attributes, child }) {
+  const { ConsoleProvider, create } = require('node:logger');
+
+  let logger = create(provider === 'console' ?
+    new ConsoleProvider({ level: 'info' }) :
+    {
+      isEnabled(level) { return level.value >= 30; },
+      log() {},
+    });
+  if (child) logger = logger.child({ requestId: 1 });
+
+  if (attributes === 'object') {
+    bench.start();
+    for (let i = 0; i < n; i++) logger.debug('hello', { i });
+    bench.end(n);
+  } else {
+    bench.start();
+    for (let i = 0; i < n; i++) logger.debug('hello');
+    bench.end(n);
+  }
+}
diff --git a/benchmark/logger/enabled.js b/benchmark/logger/enabled.js
new file mode 100644
index 000000000000..a4771ca39c15
--- /dev/null
+++ b/benchmark/logger/enabled.js
@@ -0,0 +1,50 @@
+'use strict';
+
+// Cost of composing an enabled log event, with a provider that does no work.
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [1e6],
+  provider: ['minimal', 'custom'],
+  variant: ['no-attributes', 'attributes', 'function-binding'],
+}, {
+  flags: ['--experimental-logger', '--no-warnings'],
+});
+
+function main({ n, provider, variant }) {
+  const { create } = require('node:logger');
+  const { AsyncLocalStorage } = require('node:async_hooks');
+
+  let last;
+  const log = (event) => { last = event; };
+  const als = new AsyncLocalStorage();
+  const bindings = variant === 'function-binding' ?
+    { service: 'api', request: () => als.getStore() } :
+    { service: 'api' };
+  const logger = create(provider === 'minimal' ? { log } : {
+    isEnabled(level) { return level.value >= 30; },
+    log,
+  }, { name: 'bench', bindings });
+
+  switch (variant) {
+    case 'no-attributes':
+      bench.start();
+      for (let i = 0; i < n; i++) logger.info('hello');
+      bench.end(n);
+      break;
+    case 'attributes':
+      bench.start();
+      for (let i = 0; i < n; i++) logger.info('hello', { i, user: 'x' });
+      bench.end(n);
+      break;
+    case 'function-binding':
+      als.enterWith(1);
+      bench.start();
+      for (let i = 0; i < n; i++) logger.info('hello', { i });
+      bench.end(n);
+      break;
+  }
+
+  if (last === undefined) throw new Error('no event was logged');
+}
diff --git a/benchmark/logger/request.js b/benchmark/logger/request.js
new file mode 100644
index 000000000000..75f627b9ab9c
--- /dev/null
+++ b/benchmark/logger/request.js
@@ -0,0 +1,43 @@
+'use strict';
+
+// A child logger per request, logging a few lines through ConsoleProvider.
+// The provider's stream write() is replaced to avoid I/O latency.
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  n: [5e5],
+  lines: [0, 1, 3],
+  level: ['info', 'debug'],
+}, {
+  flags: ['--experimental-logger', '--no-warnings'],
+});
+
+function main({ n, lines, level }) {
+  const { ConsoleProvider, create } = require('node:logger');
+
+  // With level 'debug' the lines are disabled (the provider is at 'info').
+  const provider = new ConsoleProvider({ level: 'info' });
+  let bytes = 0;
+  provider.stream.write = (data) => {
+    bytes += data.length;
+    return true;
+  };
+  const logger = create(provider, {
+    name: 'bench',
+    bindings: { service: 'api' },
+  });
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    const child = logger.child({ requestId: i });
+    for (let j = 0; j < lines; j++) {
+      child[level]('handled', { step: j });
+    }
+  }
+  bench.end(n);
+
+  if (lines > 0 && level === 'info' && bytes === 0) {
+    throw new Error('nothing was serialized');
+  }
+}
diff --git a/doc/api/cli.md b/doc/api/cli.md
index b57714a0bfa2..e8fe47010d6a 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1545,6 +1545,16 @@ 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.1 - Active development
+
+Enable the experimental [`node:logger`][] module.
+
 ### `--experimental-network-inspection`
 
 <!-- YAML
@@ -4276,6 +4286,7 @@ one is included in the list below.
 * `--experimental-import-text`
 * `--experimental-json-modules`
 * `--experimental-loader`
+* `--experimental-logger`
 * `--experimental-modules`
 * `--experimental-package-map`
 * `--experimental-print-required-tla`
@@ -4961,6 +4972,7 @@ node --stack-trace-limit=12 -p -e "Error.stackTraceLimit" # prints 12
 [`inspector.open()`]: inspector.md#inspectoropenport-host-wait
 [`net.getDefaultAutoSelectFamilyAttemptTimeout()`]: net.md#netgetdefaultautoselectfamilyattempttimeout
 [`node:ffi`]: ffi.md
+[`node:logger`]: logger.md
 [`node:sqlite`]: sqlite.md
 [`node:stream/iter`]: stream_iter.md
 [`node:vfs`]: vfs.md
diff --git a/doc/api/index.md b/doc/api/index.md
index a30724c064e1..b3533dbd9f2e 100644
--- a/doc/api/index.md
+++ b/doc/api/index.md
@@ -36,6 +36,7 @@
 * [Inspector](inspector.md)
 * [Internationalization](intl.md)
 * [Iterable Streams API](stream_iter.md)
+* [Logger](logger.md)
 * [Modules: CommonJS modules](modules.md)
 * [Modules: ECMAScript modules](esm.md)
 * [Modules: `node:module` API](module.md)
diff --git a/doc/api/logger.md b/doc/api/logger.md
new file mode 100644
index 000000000000..a7af6f8cae6a
--- /dev/null
+++ b/doc/api/logger.md
@@ -0,0 +1,624 @@
+# Logger
+
+<!--introduced_in=REPLACEME-->
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.1 - Active development
+
+<!-- source_link=lib/logger.js -->
+
+The `node:logger` module provides a structured logging facade. A logger composes
+log events and passes them to a provider. Providers control filtering, encoding,
+buffering, and output.
+
+```mjs
+import create from 'node:logger';
+
+const logger = create({ name: 'example' });
+logger.info('server started', { port: 3000 });
+```
+
+```cjs
+const create = require('node:logger');
+
+const logger = create({ name: 'example' });
+logger.info('server started', { port: 3000 });
+```
+
+The module is only available under the `node:` scheme, and only when Node.js is
+started with the [`--experimental-logger`][] flag.
+
+## Log events
+
+Providers receive a log event with the following properties:
+
+* `timestamp` {number} Milliseconds since the Unix epoch.
+* `level` {Object}
+  * `name` {string} The level name.
+  * `value` {number} The numeric level value. Larger values are more severe.
+* `name` {string|undefined} The logger name.
+* `message` {any} The log message value.
+* `bindings` {Object} Attributes associated with the logger and its parents.
+* `attributes` {Object} Attributes supplied for this event.
+
+A new event object is created for each log call and is not frozen. The
+`attributes` object is a shallow copy of the attributes supplied for the event
+and is not frozen. Built-in levels and the logger's bindings are shared between
+events and are shallowly frozen. When a direct value of the bindings is a
+function, `bindings` is instead a new, unfrozen copy. The message value is
+retained as provided and is not cloned or frozen. Nested values are not cloned
+or frozen. Providers should treat the entire event as read-only, since an
+[`AggregateProvider`][] passes the same event to each of its providers, and
+must copy nested values before retaining or modifying them asynchronously.
+
+If a direct value of `bindings` or `attributes` is a function, the logger invokes
+it for every event and replaces it in the event with the returned value. Nested
+functions are not invoked.
+
+## `logger.getDefaultProvider()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {Object}
+
+Returns the provider used when a logger is created without an explicit provider.
+Until set, the first call or logger creation lazily creates a
+[`ConsoleProvider`][]. The same default provider is reused by subsequent loggers.
+
+## `logger.setDefaultProvider(provider)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `provider` {Object} The provider to use by default.
+
+Sets the provider used when a logger is created without an explicit provider.
+Existing loggers retain their provider.
+
+```cjs
+const create = require('node:logger');
+
+create.setDefaultProvider(new create.EventProvider());
+const logger = create();
+```
+
+When `provider` differs from the current default, the process emits the
+[`'defaultLoggerProviderChanged'`][] event with `provider` and the current
+default provider. This event allows an application to detect when a dependency
+changes the default provider. If the application does not wish to allow the
+default provider to be changed, it can throw an error synchronously which will
+be propagated up to the code that called `setDefaultProvider()`.
+
+## `logger.create([provider][, options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `provider` {Object} The provider that receives log events. **Default:**
+  The value returned by [`logger.getDefaultProvider()`][].
+* `options` {Object}
+  * `name` {string} The logger name.
+  * `bindings` {Object} Attributes included in every event from the logger.
+    **Default:** `{}`.
+* Returns: {Logger}
+
+Creates a logger. If the first argument does not implement the provider
+contract, it is treated as `options`.
+
+```cjs
+const { create, EventProvider } = require('node:logger');
+
+const defaultLogger = create();
+
+const provider = new EventProvider();
+provider.on('log', (event) => {
+  // Handle the structured event.
+});
+const eventLogger = create(provider, {
+  name: 'api',
+  bindings: { service: 'users' },
+});
+```
+
+## Provider contract
+
+A provider is an object with a synchronous `log(event, context)` method. It may also
+implement `isEnabled(level, context)` to prevent events from being composed:
+
+```cjs
+class CustomProvider {
+  isEnabled(level, context) {
+    return level.value >= 30;
+  }
+
+  log(event, context) {
+    // Handle the structured event.
+  }
+}
+```
+
+The `level` passed to `isEnabled()` is a level descriptor, which is frozen for
+built-in levels. The same `context` object is passed to both methods for every
+event from a logger and contains the logger's `name` and `bindings`. Providers
+should not modify it. Only an exact `false` return value disables the event. A
+provider without `isEnabled()` receives every event.
+
+Provider methods run synchronously in the logging call. Exceptions propagate to
+the caller. A provider that performs asynchronous work must enqueue or copy the
+event synchronously.
+
+## Class: `Logger`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+### `new Logger([provider][, options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `provider` {Object} The provider that receives log events. **Default:**
+  The value returned by [`logger.getDefaultProvider()`][].
+* `options` {Object}
+  * `name` {string} The logger name.
+  * `bindings` {Object} Attributes included in every event from the logger.
+
+Equivalent to [`logger.create()`][].
+
+### `logger.provider`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {Object}
+
+The provider used by the logger. The property is read-only.
+
+### `logger.name`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {string|undefined}
+
+The logger name.
+
+### `logger.bindings`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {Object}
+
+The shallowly frozen bindings associated with the logger.
+
+### `logger.trace(message[, attributes])`
+
+### `logger.debug(message[, attributes])`
+
+### `logger.info(message[, attributes])`
+
+### `logger.warn(message[, attributes])`
+
+### `logger.error(message[, attributes])`
+
+### `logger.fatal(message[, attributes])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `message` {any} The log message value.
+* `attributes` {Object} Attributes associated with this event. **Default:** `{}`.
+
+Creates a structured event at the corresponding level and passes it to the
+provider if the provider enables that level.
+
+When the provider is a [`ConsoleProvider`][], an [`EventProvider`][], or an
+[`AggregateProvider`][] made up only of those providers and providers without
+`isEnabled()`, these methods are resolved when the logger is created and again
+whenever a provider's `level` changes. Methods for disabled levels are then a
+shared no-op function, so calling them does not consult the provider. The
+JavaScript engine can usually optimize such calls away entirely. Because of
+this, methods for disabled levels do not validate their receiver or arguments.
+For other providers, including providers that override `isEnabled()`, each call
+checks `isEnabled()`.
+
+```cjs
+const { ConsoleProvider, create } = require('node:logger');
+
+const provider = new ConsoleProvider({ level: 'info' });
+const logger = create(provider);
+logger.debug('not logged'); // No-op.
+provider.level = 'debug';
+logger.debug('logged');
+```
+
+```cjs
+logger.info('request completed', {
+  method: 'GET',
+  statusCode: 200,
+});
+```
+
+### `logger.log(level, message[, attributes])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `level` {string|Object} A built-in level name or an object containing a
+  `name` {string} and integer `value` {number}.
+* `message` {any} The log message value.
+* `attributes` {Object} Attributes associated with this event. **Default:** `{}`.
+
+Creates an event at a built-in or custom level.
+
+```cjs
+logger.log({ name: 'notice', value: 35 }, 'configuration reloaded');
+```
+
+### `logger.isEnabled(level)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `level` {string|Object} A built-in level name or custom level descriptor.
+* Returns: {boolean}
+
+Returns whether the provider enables the level for this logger.
+
+### `logger.child(bindings[, options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `bindings` {Object} Additional logger bindings.
+* `options` {Object}
+  * `name` {string} A name for the child. **Default:** The parent logger's name.
+* Returns: {Logger}
+
+Creates a logger that uses the same provider and adds to the parent's bindings.
+Child bindings with the same key replace parent bindings.
+
+## Class: `AggregateProvider`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+The `AggregateProvider` delivers log events to a fixed list of providers. It
+enables an event when at least one provider enables it. Each provider's
+`isEnabled()` method is checked again immediately before delivery, and a
+provider that returns `false` does not receive the event. Providers are called
+in list order. Exceptions propagate immediately and prevent later providers
+from being called.
+
+### `new AggregateProvider(providers)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `providers` {Object\[]} The providers that receive log events.
+
+The array may be empty. The providers are copied and validated during
+construction. Duplicate and nested aggregate providers are supported.
+
+### `aggregateProvider.providers`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {Object\[]}
+
+The frozen provider list. The provider objects themselves are not frozen.
+
+## Class: `ConsoleProvider`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+The `ConsoleProvider` serializes each event and writes it followed by a newline
+using [`fs.Utf8Stream`][]. Events are serialized as JSON by default.
+
+### `new ConsoleProvider([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `options` {Object}
+  * `destination` {string} Either `'stdout'` or `'stderr'`. **Default:**
+    `'stdout'`.
+  * `flatten` {boolean} Whether to copy bindings and attributes into the
+    top-level serialized record. **Default:** `false`.
+  * `level` {string|Object} The minimum enabled level. **Default:** `'info'`.
+  * `maxLength` {number} The maximum internal buffer length. Writes that would
+    exceed this value are dropped. **Default:** `0`, for no limit.
+  * `minLength` {number} The minimum internal buffer length before an automatic
+    flush. **Default:** `0`.
+  * `periodicFlush` {number} The interval in milliseconds at which the stream
+    is flushed. **Default:** `0`, for no periodic flush.
+  * `pid` {boolean} Whether to add the process ID as a top-level `pid` property
+    to serialized records. **Default:** `false`.
+  * `serializer` {Function} A function that receives a log record and returns
+    a string. **Default:** A JSON serializer.
+  * `sync` {boolean} Whether writes are synchronous. **Default:** `false`.
+
+When `flatten` is `true`, bindings are copied into the top-level record first,
+followed by attributes. Attributes therefore replace bindings with the same
+property name. The level descriptor is emitted as a numeric `level` property and
+a string `levelName` property. The `level`, `levelName`, `message`, `name`, and
+`timestamp` event properties, along with `pid` when enabled, take precedence
+over both. The original `bindings` and `attributes` containers are not included
+in the record.
+
+The default serializer follows [`JSON.stringify()`][] semantics, including
+calling `toJSON()` methods, with these additions:
+
+* `BigInt` values are serialized as decimal strings.
+* `Error` objects include their `name`, `message`, and `stack`, along with
+  `code`, `cause`, `errors`, and enumerable properties when present.
+* Circular references are serialized as the string `'[Circular]'`.
+
+Values that [`JSON.stringify()`][] normally omits, such as `undefined`,
+functions, and symbols used as object properties, are still omitted.
+
+[`util.inspect()`][] can be used when JavaScript-style diagnostic output is
+preferred over JSON:
+
+```cjs
+const { ConsoleProvider, create } = require('node:logger');
+const { inspect } = require('node:util');
+
+const logger = create(new ConsoleProvider({ serializer: inspect }));
+logger.info('started', { processId: 1n });
+```
+
+### `consoleProvider.destination`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {string}
+
+The configured destination.
+
+### `consoleProvider.flatten`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+Whether bindings and attributes are flattened into the serialized record.
+
+### `consoleProvider.level`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {Object}
+
+The minimum level descriptor. Set this property to a built-in level name or a
+custom level descriptor to update the minimum level.
+
+### `consoleProvider.pid`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+Whether serialized records include the process ID.
+
+### `consoleProvider.serializer`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {Function}
+
+The configured serializer.
+
+### `consoleProvider.stream`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {fs.Utf8Stream}
+
+The underlying stream. Its `'drop'` event reports records dropped because of
+`maxLength`.
+
+### `consoleProvider.flush([callback])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `callback` {Function} Called when pending writes have completed.
+
+Flushes pending writes.
+
+### `consoleProvider.flushSync()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Synchronously flushes pending writes. An `ERR_INVALID_STATE` error is thrown if
+the provider's stream is currently writing.
+
+## Class: `DiagnosticsProvider`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+The `DiagnosticsProvider` publishes enabled log events to
+[`diagnostics_channel`][] channels. Events are only enabled for channels that
+have subscribers.
+
+### `new DiagnosticsProvider(channels)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `channels` {Object|Function} A channel mapping or routing function.
+
+When `channels` is an object, each own string or symbol property is a channel
+name and its value is a selector function that receives a level descriptor. The
+event is published to every subscribed channel whose selector returns a truthy
+value.
+
+When `channels` is a function, it receives a level descriptor and returns the
+string or symbol name of the channel to publish to. Returning `undefined`
+disables the event. The selected channel must have subscribers for the event to
+be enabled.
+
+`DiagnosticsProvider.isEnabled()` invokes the routing function to resolve its
+channel. For a channel mapping, it invokes selectors only for channels that
+currently have subscribers and stops after the first matching selector. When an
+event is enabled, the applicable routing function or selectors are invoked
+again immediately before publishing it. These functions must not rely on being
+called exactly once.
+
+```cjs
+const { DiagnosticsProvider, create, levels } = require('node:logger');
+
+const provider = new DiagnosticsProvider({
+  'application:log': () => true,
+  'application:error': (level) => level.value >= levels.error.value,
+});
+const logger = create(provider);
+```
+
+## Class: `EventProvider`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Extends: {EventEmitter}
+
+For each enabled log event, the `EventProvider` first checks for listeners whose
+event name exactly matches the level name. If any exist, it emits the event using
+the level name. Otherwise, it emits a `'log'` event. Event selection is based
+only on the level name, not its numeric value. The provider does not buffer log
+events, so events emitted without a matching or fallback listener are discarded.
+
+### `new EventProvider([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `options` {Object}
+  * `level` {string|Object} The minimum enabled level. **Default:** `'trace'`.
+
+### Event: `'<level name>'`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `event` {Object} The structured log event.
+
+Emitted synchronously when the provider has a listener for the exact level name.
+This event takes precedence over the `'log'` event.
+
+```mjs
+import { create, EventProvider } from 'node:logger';
+
+const ep = new EventProvider();
+
+ep.on('warn', (event) => {
+  // Receives all warn logs
+});
+
+ep.on('log', (event) => {
+  // Receives all other logs
+});
+
+const logger = create(ep);
+logger.warn('warning!');
+logger.info('info!');
+```
+
+### Event: `'log'`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `event` {Object} The structured log event.
+
+Emitted synchronously when the provider has no listener for the event's level
+name.
+
+### `eventProvider.level`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {Object}
+
+The minimum level descriptor. Set this property to a built-in level name or a
+custom level descriptor to update the minimum level.
+
+## `logger.levels`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {Object}
+
+Immutable descriptors for the built-in levels:
+
+| Name    | Value |
+| ------- | ----: |
+| `trace` |    10 |
+| `debug` |    20 |
+| `info`  |    30 |
+| `warn`  |    40 |
+| `error` |    50 |
+| `fatal` |    60 |
+
+[`'defaultLoggerProviderChanged'`]: process.md#event-defaultloggerproviderchanged
+[`--experimental-logger`]: cli.md#--experimental-logger
+[`AggregateProvider`]: #class-aggregateprovider
+[`ConsoleProvider`]: #class-consoleprovider
+[`EventProvider`]: #class-eventprovider
+[`JSON.stringify()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
+[`diagnostics_channel`]: diagnostics_channel.md
+[`fs.Utf8Stream`]: fs.md#class-fsutf8stream
+[`logger.create()`]: #loggercreateprovider-options
+[`logger.getDefaultProvider()`]: #loggergetdefaultprovider
+[`util.inspect()`]: util.md#utilinspectobject-options
diff --git a/doc/api/process.md b/doc/api/process.md
index 8b210a1e7c06..6fd4b53701eb 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -80,6 +80,20 @@ console.log('This message is displayed first.');
 // Process exit event with code: 0
 ```
 
+### Event: `'defaultLoggerProviderChanged'`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `provider` {Object} The new default logger provider.
+* `defaultProvider` {Object|undefined} The default logger provider at the time
+  the event is emitted.
+
+The `'defaultLoggerProviderChanged'` event is emitted synchronously when
+[`logger.setDefaultProvider()`][] is called with a provider that differs from
+the current default provider.
+
 ### Event: `'disconnect'`
 
 <!-- YAML
@@ -4652,6 +4666,7 @@ cases:
 [`console.error()`]: console.md#consoleerrordata-args
 [`console.log()`]: console.md#consolelogdata-args
 [`domain`]: domain.md
+[`logger.setDefaultProvider()`]: logger.md#loggersetdefaultproviderprovider
 [`module.getSourceMapsSupport()`]: module.md#modulegetsourcemapssupport
 [`module.isBuiltin(id)`]: module.md#moduleisbuiltinmodulename
 [`module.setSourceMapsSupport()`]: module.md#modulesetsourcemapssupportenabled-options
diff --git a/doc/node.1 b/doc/node.1
index 36a7cc720440..48237dc3f31b 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -878,6 +878,9 @@ Specify the \fBmodule\fR containing exported asynchronous module customization h
 \fBmodule\fR may be any string accepted as an \fBimport\fR specifier.
 This feature requires \fB--allow-worker\fR if used with the Permission Model.
 .
+.It Fl -experimental-logger
+Enable the experimental \fBnode:logger\fR module.
+.
 .It Fl -experimental-network-inspection
 Enable experimental support for the network inspection with Chrome DevTools.
 .
@@ -2253,6 +2256,8 @@ one is included in the list below.
 .It
 \fB--experimental-loader\fR
 .It
+\fB--experimental-logger\fR
+.It
 \fB--experimental-modules\fR
 .It
 \fB--experimental-package-map\fR
diff --git a/lib/internal/bootstrap/realm.js b/lib/internal/bootstrap/realm.js
index 0be0998e7ee0..9e5d27a6c563 100644
--- a/lib/internal/bootstrap/realm.js
+++ b/lib/internal/bootstrap/realm.js
@@ -128,6 +128,7 @@ const schemelessBlockList = new SafeSet([
   'bench/reporters',
   'dtls',
   'ffi',
+  'logger',
   'sea',
   'sqlite',
   'quic',
@@ -141,6 +142,7 @@ const experimentalModuleList = new SafeSet([
   'bench/reporters',
   'dtls',
   'ffi',
+  'logger',
   'quic',
   'sqlite',
   'stream/iter',
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 57bfb8eb845b..678c31714827 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -120,6 +120,7 @@ function prepareExecution(options) {
   setupWarningHandler();
   setupBench();
   setupFFI();
+  setupLogger();
   setupSQLite();
   setupStreamIter();
   setupDTLS();
@@ -510,6 +511,15 @@ function setupFFI() {
   BuiltinModule.allowRequireByUsers('ffi');
 }
 
+function setupLogger() {
+  if (!getOptionValue('--experimental-logger')) {
+    return;
+  }
+
+  const { BuiltinModule } = require('internal/bootstrap/realm');
+  BuiltinModule.allowRequireByUsers('logger');
+}
+
 function setupSQLite() {
   if (getOptionValue('--no-experimental-sqlite')) {
     return;
diff --git a/lib/logger.js b/lib/logger.js
new file mode 100644
index 000000000000..cb0d593d3e6e
--- /dev/null
+++ b/lib/logger.js
@@ -0,0 +1,1510 @@
+'use strict';
+
+const {
+  ArrayPrototypeIncludes,
+  ArrayPrototypePop,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  DateNow,
+  FunctionPrototypeCall,
+  JSONStringify,
+  NumberIsFinite,
+  ObjectAssign,
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  ObjectFreeze,
+  ObjectGetOwnPropertySymbols,
+  ObjectGetPrototypeOf,
+  ObjectKeys,
+  ObjectPrototypeHasOwnProperty,
+  ObjectPrototypePropertyIsEnumerable,
+  ObjectSetPrototypeOf,
+  ReflectOwnKeys,
+  SafeMap,
+  SafeSet,
+  SafeWeakMap,
+  SafeWeakRef,
+  String,
+  StringPrototypeCharCodeAt,
+  Symbol,
+} = primordials;
+
+const {
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_RETURN_VALUE,
+    ERR_INVALID_STATE,
+    ERR_INVALID_THIS,
+  },
+} = require('internal/errors');
+const {
+  validateArray,
+  validateBoolean,
+  validateFunction,
+  validateInteger,
+  validateObject,
+  validateOneOf,
+  validateString,
+} = require('internal/validators');
+const {
+  emitExperimentalWarning,
+  isError,
+  kEmptyObject,
+} = require('internal/util');
+const Utf8Stream = require('internal/streams/fast-utf8-stream');
+const { channel: diagnosticsChannel } = require('diagnostics_channel');
+const EventEmitter = require('events');
+
+// Objects created per logger or per event (levels, bindings, attributes,
+// contexts, events, records) must not inherit from Object.prototype, and
+// should be in fast properties mode. `{ __proto__: null }` literals and
+// ObjectCreate(null) produce dictionary-mode objects, and calling
+// ObjectSetPrototypeOf() on a new object is expensive. Instead, these
+// objects are created by constructor functions whose prototype is this
+// shared, empty, frozen object, whose own prototype is null. Such objects
+// are allocated in fast mode and inherit no properties.
+//
+// Objects created only once (at module load or per provider) use
+// ObjectSetPrototypeOf(obj, null) directly, since the cost is paid once.
+const kNullPrototype = {};
+ObjectSetPrototypeOf(kNullPrototype, null);
+ObjectFreeze(kNullPrototype);
+
+function NullPrototypeObject() {}
+NullPrototypeObject.prototype = kNullPrototype;
+
+function Level(name, value) {
+  this.name = name;
+  this.value = value;
+}
+Level.prototype = kNullPrototype;
+
+// Returns ConsoleProvider's cached serialization of `bindings` (see
+// getSerializedBindings()) if `context` is the context of the logger that
+// owns them, otherwise undefined. Set in LoggerContext's static block.
+let getContextSerializedBindings;
+
+class LoggerContext {
+  // Internal state, invisible to providers.
+  #bindings;
+  #name;
+  // The parent logger's context, for child loggers.
+  #parent;
+  // ConsoleProvider's SerializedBindings for #bindings, once computed.
+  #serializedBindings;
+
+  constructor(bindings, name, parent) {
+    this.bindings = bindings;
+    this.name = name;
+    this.#bindings = bindings;
+    this.#name = name;
+    this.#parent = parent;
+  }
+
+  static {
+    getContextSerializedBindings = (context, bindings) => {
+      if (typeof context !== 'object' || context === null ||
+          !(#bindings in context) || context.#bindings !== bindings) {
+        return undefined;
+      }
+      let serialized = context.#serializedBindings;
+      if (serialized === undefined) {
+        // The bindings are frozen, and only cached if all values are
+        // primitives (see serializeFields()), so this cannot go stale.
+        const parent = context.#parent;
+        const name = context.#name;
+        if (parent !== undefined) {
+          serialized = composeBindings(
+            bindings,
+            parent.#bindings,
+            getContextSerializedBindings(parent, parent.#bindings),
+            name);
+        }
+        serialized ??= serializeBindings(bindings, name);
+        context.#serializedBindings = serialized;
+      }
+      return serialized;
+    };
+  }
+}
+// Contexts look like plain null-prototype objects to providers.
+ObjectSetPrototypeOf(LoggerContext.prototype, null);
+delete LoggerContext.prototype.constructor;
+ObjectFreeze(LoggerContext.prototype);
+
+// Returns whether `obj` is an event created by Logger. Set in LogEvent's
+// static block.
+let isLogEvent;
+
+class LogEvent {
+  // Lets ConsoleProvider recognize events created by Logger. Cheaper than
+  // checking the prototype.
+  #brand;
+
+  constructor(attributes, bindings, level, message, name, timestamp) {
+    this.attributes = attributes;
+    this.bindings = bindings;
+    this.level = level;
+    this.message = message;
+    this.name = name;
+    this.timestamp = timestamp;
+  }
+
+  static {
+    isLogEvent = (obj) => #brand in obj;
+  }
+}
+// Events look like plain null-prototype objects to providers.
+ObjectSetPrototypeOf(LogEvent.prototype, null);
+delete LogEvent.prototype.constructor;
+ObjectFreeze(LogEvent.prototype);
+
+const kEmpty = ObjectFreeze(new NullPrototypeObject());
+const kDestinations = ['stdout', 'stderr'];
+const kEmptyAttributes = kEmpty;
+const kEmptyBindings = kEmpty;
+
+// Objects created per event (events, attribute copies, custom levels passed
+// to log(), records) are not frozen: each is new, so mutating one affects
+// nothing else, consistent with EventEmitter and diagnostics_channel.
+// Objects that are shared or reused (the built-in levels, provider level
+// thresholds, logger bindings, kEmpty, kNullPrototype) are frozen.
+
+// The built-in levels are shared by every logger and provider.
+let levels = {
+  trace: ObjectFreeze(new Level('trace', 10)),
+  debug: ObjectFreeze(new Level('debug', 20)),
+  info: ObjectFreeze(new Level('info', 30)),
+  warn: ObjectFreeze(new Level('warn', 40)),
+  error: ObjectFreeze(new Level('error', 50)),
+  fatal: ObjectFreeze(new Level('fatal', 60)),
+};
+ObjectSetPrototypeOf(levels, null);
+levels = ObjectFreeze(levels);
+const kLevelNames = ObjectKeys(levels);
+
+function normalizeLevel(level, name = 'level') {
+  if (typeof level === 'string') {
+    validateOneOf(level, name, kLevelNames);
+    return levels[level];
+  }
+
+  validateObject(level, name);
+  const { name: levelName, value } = level;
+  validateString(levelName, `${name}.name`);
+  validateInteger(value, `${name}.value`);
+  return new Level(levelName, value);
+}
+
+// Provider level thresholds are frozen: they are exposed through the
+// provider's `level` getter, and mutating one would change which levels are
+// enabled without re-resolving loggers' level methods.
+function normalizeThreshold(level, name = 'level') {
+  return ObjectFreeze(normalizeLevel(level, name));
+}
+
+// Copies the own enumerable properties of `value`, like ObjectAssign().
+// With `resolveFunctions`, function values are replaced by their return
+// value, in the same pass.
+function copyObject(value, resolveFunctions = false) {
+  if (!resolveFunctions) {
+    return ObjectAssign(new NullPrototypeObject(), value);
+  }
+  const copy = new NullPrototypeObject();
+  const keys = ObjectKeys(value);
+  for (let i = 0; i < keys.length; i++) {
+    copyResolvedProperty(copy, value, keys[i]);
+  }
+  const symbols = ObjectGetOwnPropertySymbols(value);
+  for (let i = 0; i < symbols.length; i++) {
+    if (ObjectPrototypePropertyIsEnumerable(value, symbols[i])) {
+      copyResolvedProperty(copy, value, symbols[i]);
+    }
+  }
+  return copy;
+}
+
+function copyResolvedProperty(copy, value, key) {
+  const entry = value[key];
+  copy[key] = typeof entry === 'function' ?
+    FunctionPrototypeCall(entry) : entry;
+}
+
+// Returns whether any own enumerable property (the ones copyObject() and
+// ObjectAssign() copy) is a function. ObjectKeys() and
+// ObjectGetOwnPropertySymbols() are much cheaper than ReflectOwnKeys().
+function hasFunction(value) {
+  const keys = ObjectKeys(value);
+  for (let i = 0; i < keys.length; i++) {
+    if (typeof value[keys[i]] === 'function') {
+      return true;
+    }
+  }
+  const symbols = ObjectGetOwnPropertySymbols(value);
+  for (let i = 0; i < symbols.length; i++) {
+    if (ObjectPrototypePropertyIsEnumerable(value, symbols[i]) &&
+        typeof value[symbols[i]] === 'function') {
+      return true;
+    }
+  }
+  return false;
+}
+
+function isProvider(value) {
+  return value !== null &&
+    (typeof value === 'object' || typeof value === 'function') &&
+    typeof value.log === 'function';
+}
+
+function validateProvider(provider, name = 'provider') {
+  if (provider === null ||
+      (typeof provider !== 'object' && typeof provider !== 'function')) {
+    throw new ERR_INVALID_ARG_TYPE(name, 'Provider', provider);
+  }
+
+  validateFunction(provider.log, `${name}.log`);
+  if (provider.isEnabled !== undefined) {
+    validateFunction(provider.isEnabled, `${name}.isEnabled`);
+  }
+}
+
+function isProviderEnabled(provider, level, context) {
+  const isEnabled = provider.isEnabled;
+  return isEnabled === undefined || FunctionPrototypeCall(
+    isEnabled,
+    provider,
+    level,
+    context,
+  ) !== false;
+}
+
+// Level method dispatch
+//
+// When a provider's enablement can only change through paths this module
+// observes, the per-level methods (`trace()`, `debug()`, etc.) are resolved
+// ahead of time instead of checking `isEnabled()` on every call. Disabled
+// levels are bound to a shared empty function, which the JIT can inline away
+// entirely at monomorphic call sites (the same technique pino uses).
+//
+// The resolved methods live on a dispatch prototype that is shared by every
+// logger with the same provider and the same logger prototype. Re-resolving
+// after a level change therefore updates a single object, rather than having
+// to track every logger instance (child loggers are often created per
+// request).
+//
+// Providers whose enablement may change without notice (a custom
+// `isEnabled()`, or `DiagnosticsProvider`, which depends on channel
+// subscriptions) keep the per-call `isEnabled()` check.
+
+function noop() {}
+
+// Populated after the Logger class is defined: level name -> the real
+// (checking) Logger.prototype method.
+let kLevelMethods;
+// Populated after the Logger class is defined. See getDispatchPrototype().
+let createDispatchClass;
+let isAggregateDispatchable;
+let aggregateIsEnabled;
+
+// Built-in isEnabled() implementations whose result only changes through a
+// level setter that calls invalidateDispatch(). Populated by the providers.
+const kObservableIsEnabled = new SafeSet();
+
+// provider -> { prototypes: SafeMap<base, dispatch>, dependents: SafeSet }
+const dispatchStates = new SafeWeakMap();
+// Maps dispatch prototype -> { provider, base, target }, where `target` is
+// the generated Logger subclass whose prototype is the dispatch object, or
+// undefined for dispatch objects of other bases.
+const dispatchInfo = new SafeWeakMap();
+
+function getDispatchState(provider) {
+  let state = dispatchStates.get(provider);
+  if (state === undefined) {
+    state = {
+      prototypes: new SafeMap(),
+      // WeakRefs to aggregate providers that must be re-resolved when this
+      // provider's enablement changes.
+      dependents: new SafeSet(),
+    };
+    dispatchStates.set(provider, state);
+  }
+  return state;
+}
+
+/**
+ * Returns whether every change to the provider's enablement is observed by
+ * this module, making it safe to resolve level methods ahead of time.
+ * @param {object} provider
+ * @returns {boolean}
+ */
+function isDispatchable(provider) {
+  const isEnabled = provider.isEnabled;
+  return isEnabled === undefined ||
+    kObservableIsEnabled.has(isEnabled) ||
+    (isEnabled === aggregateIsEnabled && isAggregateDispatchable(provider));
+}
+
+function resolveDispatchPrototype(provider, dispatch) {
+  for (let i = 0; i < kLevelNames.length; i++) {
+    const name = kLevelNames[i];
+    // Level methods overridden by a Logger subclass are not managed.
+    if (!ObjectPrototypeHasOwnProperty(dispatch, name)) continue;
+    // Built-in dispatchable providers do not depend on the logger context.
+    const method = isProviderEnabled(provider, levels[name], undefined) ?
+      kLevelMethods[name] : noop;
+    // Avoid needless writes, which invalidate optimized code.
+    if (dispatch[name] !== method) dispatch[name] = method;
+  }
+}
+
+/**
+ * Returns the dispatch prototype for loggers using `provider` whose prototype
+ * would otherwise be `base`, or `undefined` if level methods must check the
+ * provider on every call.
+ * @param {object} provider
+ * @param {object} base
+ * @returns {object|undefined}
+ */
+function getDispatchPrototype(provider, base) {
+  // Without isEnabled() every level is always enabled, so the regular
+  // prototype methods are already the right ones.
+  if (provider.isEnabled === undefined || !isDispatchable(provider)) {
+    return undefined;
+  }
+  const state = getDispatchState(provider);
+  let dispatch = state.prototypes.get(base);
+  if (dispatch === undefined) {
+    // For plain loggers, the dispatch prototype is the prototype of a
+    // generated Logger subclass, so that create() and child() can allocate
+    // loggers with it directly using `new`. (Changing the prototype of an
+    // existing object, and ReflectConstruct() with another new.target, are
+    // both much slower.) Other bases only get the prototype swapped in.
+    const target = createDispatchClass(base);
+    dispatch = target === undefined ? { __proto__: base } : target.prototype;
+    for (let i = 0; i < kLevelNames.length; i++) {
+      const name = kLevelNames[i];
+      if (base[name] !== kLevelMethods[name]) continue;
+      const desc = {
+        configurable: true,
+        enumerable: false,
+        value: noop,
+        writable: true,
+      };
+      ObjectSetPrototypeOf(desc, null);
+      ObjectDefineProperty(dispatch, name, desc);
+    }
+    resolveDispatchPrototype(provider, dispatch);
+    state.prototypes.set(base, dispatch);
+    dispatchInfo.set(dispatch, {
+      __proto__: null,
+      base,
+      provider,
+      target,
+    });
+  }
+  return dispatch;
+}
+
+
+/**
+ * Re-resolves level methods for all loggers using `provider`, and for all
+ * aggregate providers that include it. Must be called whenever the result of
+ * a dispatchable provider's isEnabled() may have changed.
+ * @param {object} provider
+ */
+function invalidateDispatch(provider) {
+  const state = dispatchStates.get(provider);
+  if (state === undefined) return;
+  for (const dispatch of state.prototypes.values()) {
+    resolveDispatchPrototype(provider, dispatch);
+  }
+  for (const ref of state.dependents) {
+    const dependent = ref.deref();
+    if (dependent === undefined) {
+      state.dependents.delete(ref);
+    } else {
+      invalidateDispatch(dependent);
+    }
+  }
+}
+
+function serializeError(error) {
+  const {
+    message,
+    name,
+    stack,
+    code,
+    cause,
+    errors,
+  } = error;
+  const detail = { message, name, stack };
+  const withCode = code !== undefined ? { code } : null;
+  const withCause = cause !== undefined ? { cause } : null;
+  const withErrors = errors !== undefined ? { errors } : null;
+  return ObjectAssign(new NullPrototypeObject(), error, detail,
+                      withCode, withCause, withErrors);
+}
+
+function defaultSerializer(event) {
+  const ancestors = [];
+  // Maps serialized errors back to the original. Only created if needed.
+  let replacements;
+
+  return JSONStringify(event, function replacer(_key, value) {
+    if (typeof value === 'bigint') return String(value);
+    if (value === null || typeof value !== 'object') return value;
+
+    const holder = replacements?.get(this) ?? this;
+    while (ancestors.length > 0 &&
+           ancestors[ancestors.length - 1] !== holder) {
+      ArrayPrototypePop(ancestors);
+    }
+    if (ArrayPrototypeIncludes(ancestors, value)) return '[Circular]';
+    ArrayPrototypePush(ancestors, value);
+
+    if (isError(value)) {
+      const serialized = serializeError(value);
+      replacements ??= new SafeWeakMap();
+      replacements.set(serialized, value);
+      return serialized;
+    }
+    return value;
+  });
+}
+
+// Fast path for ConsoleProvider with the default serializer
+//
+// Builds the JSON text for a Logger event directly, without creating a
+// record object or calling JSON.stringify() with a replacer for every value.
+// It produces exactly the output of defaultSerializer() for the record, and
+// gives up (returns undefined) whenever that might not hold: any value that
+// is not a primitive or an Error (objects, arrays, BigInt), errors that
+// define toJSON() or `errors` or are nested too deeply, and, when
+// flattening, any key that collides with another or is an array index
+// (which JSON orders first).
+
+// Returned when the generic serializer must be used.
+const kGeneric = Symbol('kGeneric');
+
+// Errors nested deeper than this (through `cause` or other properties) use
+// the generic serializer. This also stops cycles, which it reports as
+// '[Circular]'.
+const kMaxErrorDepth = 8;
+
+// Short strings without characters that JSON escapes are quoted directly.
+// Surrogates are left to JSONStringify(), which escapes lone ones.
+function serializeString(value) {
+  if (value.length > 64) return JSONStringify(value);
+  for (let i = 0; i < value.length; i++) {
+    const code = StringPrototypeCharCodeAt(value, i);
+    if (code < 0x20 || code === 0x22 || code === 0x5c ||
+        (code >= 0xd800 && code <= 0xdfff)) {
+      return JSONStringify(value);
+    }
+  }
+  return `"${value}"`;
+}
+
+// Property name -> `"name":`. Bounded, since keys may be data.
+const kMaxCachedKeys = 1024;
+const serializedKeyCache = new SafeMap();
+
+function serializeKey(key) {
+  let json = serializedKeyCache.get(key);
+  if (json === undefined) {
+    json = `${serializeString(key)}:`;
+    if (serializedKeyCache.size < kMaxCachedKeys) {
+      serializedKeyCache.set(key, json);
+    }
+  }
+  return json;
+}
+
+function isIndexLikeKey(key) {
+  // JSON orders array index keys first. Conservatively treat any key
+  // starting with a digit as one.
+  const code = StringPrototypeCharCodeAt(key, 0);
+  return code >= 48 && code <= 57;
+}
+
+// Returns the JSON text for a primitive value, undefined if JSON omits it,
+// or kGeneric.
+function serializePrimitive(value) {
+  switch (typeof value) {
+    case 'string': return serializeString(value);
+    case 'number': return NumberIsFinite(value) ? `${value}` : 'null';
+    case 'boolean': return value ? 'true' : 'false';
+    case 'undefined':
+    case 'function':
+    case 'symbol':
+      return undefined;
+    case 'object':
+      return value === null ? 'null' : kGeneric;
+    default:
+      // BigInt: may have a user-defined toJSON().
+      return kGeneric;
+  }
+}
+
+// Like serializePrimitive(), but also serializes errors.
+function serializeValue(value, depth) {
+  if (typeof value === 'object' && value !== null && isError(value)) {
+    return serializeErrorFast(value, depth);
+  }
+  return serializePrimitive(value);
+}
+
+/**
+ * Serializes an error the way defaultSerializer() does (see
+ * serializeError()): its own enumerable properties, followed by `message`,
+ * `name`, `stack`, `code`, and `cause` if not already present.
+ * @param {Error} error
+ * @param {number} depth
+ * @returns {string|symbol} The JSON text, or kGeneric.
+ */
+function serializeErrorFast(error, depth) {
+  if (depth >= kMaxErrorDepth || typeof error.toJSON === 'function') {
+    return kGeneric;
+  }
+  const { message, name, stack, code, cause, errors } = error;
+  if (errors !== undefined) return kGeneric;
+
+  const keys = ObjectKeys(error);
+  let out = '';
+  let hasMessage = false;
+  let hasName = false;
+  let hasStack = false;
+  let hasCode = false;
+  let hasCause = false;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    let value;
+    switch (key) {
+      case 'message': hasMessage = true; value = message; break;
+      case 'name': hasName = true; value = name; break;
+      case 'stack': hasStack = true; value = stack; break;
+      case 'code': hasCode = true; value = code; break;
+      case 'cause': hasCause = true; value = cause; break;
+      case 'errors': continue; // Undefined, checked above.
+      default:
+        if (isIndexLikeKey(key)) return kGeneric;
+        value = error[key];
+    }
+    const json = serializeValue(value, depth + 1);
+    if (json === kGeneric) return kGeneric;
+    if (json !== undefined) {
+      out += `${out === '' ? '' : ','}${serializeKey(key)}${json}`;
+    }
+  }
+
+  // Appended in this order, if not own enumerable properties of the error.
+  if (!hasMessage) out = appendErrorField(out, 'message', message, depth);
+  if (!hasName && out !== kGeneric) {
+    out = appendErrorField(out, 'name', name, depth);
+  }
+  if (!hasStack && out !== kGeneric) {
+    out = appendErrorField(out, 'stack', stack, depth);
+  }
+  if (!hasCode && code !== undefined && out !== kGeneric) {
+    out = appendErrorField(out, 'code', code, depth);
+  }
+  if (!hasCause && cause !== undefined && out !== kGeneric) {
+    out = appendErrorField(out, 'cause', cause, depth);
+  }
+  return out === kGeneric ? kGeneric : `{${out}}`;
+}
+
+function appendErrorField(out, key, value, depth) {
+  const json = serializeValue(value, depth + 1);
+  if (json === kGeneric) return kGeneric;
+  if (json === undefined) return out;
+  return `${out}${out === '' ? '' : ','}${serializeKey(key)}${json}`;
+}
+
+// Keys that a flattened record sets itself, or that change JSON key order.
+function isFlatReservedKey(key) {
+  switch (key) {
+    case 'level':
+    case 'levelName':
+    case 'message':
+    case 'name':
+    case 'pid':
+    case 'timestamp':
+      return true;
+    default:
+      return isIndexLikeKey(key);
+  }
+}
+
+/**
+ * Serializes the own enumerable string-keyed properties of `obj` as
+ * comma-separated `"key":value` pairs.
+ * @param {object} obj
+ * @param {boolean} allowErrors Whether values may be errors. Bindings may
+ *   not, since their serialization is cached and errors are mutable.
+ * @param {object} [flatBindings] When flattening attributes, the bindings
+ *   they are merged with. Reserved and colliding keys return kGeneric.
+ * @returns {string|symbol} The pairs, or kGeneric.
+ */
+function serializeFields(obj, allowErrors, flatBindings,
+                         keys = ObjectKeys(obj)) {
+  let out = '';
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (flatBindings !== undefined &&
+        (isFlatReservedKey(key) ||
+         ObjectPrototypeHasOwnProperty(flatBindings, key))) {
+      return kGeneric;
+    }
+    const value = allowErrors ?
+      serializeValue(obj[key], 0) : serializePrimitive(obj[key]);
+    if (value === undefined) continue;
+    if (value === kGeneric) return kGeneric;
+    out += `${out === '' ? '' : ','}${serializeKey(key)}${value}`;
+  }
+  return out;
+}
+
+// Serialized bindings (and name) of a logger.
+function SerializedBindings(fields, flatSafe, keys, name, nameFragment) {
+  this.fields = fields;
+  this.flatSafe = flatSafe;
+  // ObjectKeys() of the bindings, for composeBindings().
+  this.keys = keys;
+  this.name = name;
+  // `,"name":<name>`, or '' if there is no name.
+  this.nameFragment = nameFragment ?? (name === undefined ? '' :
+    `,"name":${serializeString(name)}`);
+}
+SerializedBindings.prototype = kNullPrototype;
+
+// Serializes bindings for both nested and flattened records.
+function serializeBindings(bindings, name) {
+  const keys = ObjectKeys(bindings);
+  const fields = serializeFields(bindings, false, undefined, keys);
+  let flatSafe = fields !== kGeneric;
+  if (flatSafe) {
+    for (let i = 0; i < keys.length; i++) {
+      if (isFlatReservedKey(keys[i])) {
+        flatSafe = false;
+        break;
+      }
+    }
+  }
+  return new SerializedBindings(fields, flatSafe, keys, name);
+}
+
+/**
+ * Serializes a child logger's bindings by extending its parent's
+ * serialization, if the child's bindings start with exactly the parent's
+ * keys and values (no array index keys, no overridden values).
+ * @param {object} bindings The child's merged bindings.
+ * @param {object} parentBindings
+ * @param {SerializedBindings} parentSerialized
+ * @param {string|undefined} name The child's name.
+ * @returns {SerializedBindings|undefined} undefined if not applicable.
+ */
+function composeBindings(bindings, parentBindings, parentSerialized, name) {
+  if (parentSerialized.fields === kGeneric) return undefined;
+  const keys = ObjectKeys(bindings);
+  const parentKeys = parentSerialized.keys;
+  const parentLength = parentKeys.length;
+  if (keys.length < parentLength) return undefined;
+  for (let i = 0; i < parentLength; i++) {
+    const key = parentKeys[i];
+    if (keys[i] !== key || bindings[key] !== parentBindings[key]) {
+      return undefined;
+    }
+  }
+  let fields = '';
+  let flatSafe = parentSerialized.flatSafe;
+  for (let i = parentLength; i < keys.length; i++) {
+    const key = keys[i];
+    if (isFlatReservedKey(key)) flatSafe = false;
+    const value = serializePrimitive(bindings[key]);
+    if (value === kGeneric) return undefined;
+    if (value === undefined) continue;
+    fields += `${fields === '' ? '' : ','}${serializeKey(key)}${value}`;
+  }
+  return new SerializedBindings(
+    joinFields(parentSerialized.fields, fields),
+    flatSafe,
+    keys,
+    name,
+    name === parentSerialized.name ? parentSerialized.nameFragment : undefined);
+}
+
+// Serialized bindings are cached per logger (in its context) when the event
+// carries the logger's own frozen bindings, i.e. no binding is a function.
+function getSerializedBindings(bindings, name, context) {
+  const serialized = getContextSerializedBindings(context, bindings);
+  if (serialized !== undefined && serialized.name === name) return serialized;
+  return serializeBindings(bindings, name);
+}
+
+// The serialized timestamp of the previous event, reused while consecutive
+// events have the same timestamp.
+let lastTimestamp = -1;
+let lastTimestampJSON = '';
+
+function SerializedLevel(nested, flat) {
+  // `"level":{"name":...,"value":...}` contents and flattened fields.
+  this.nested = nested;
+  this.flat = flat;
+}
+SerializedLevel.prototype = kNullPrototype;
+
+function serializeLevel(name, value) {
+  const nameJSON = serializeString(name);
+  return new SerializedLevel(`{"name":${nameJSON},"value":${value}}`,
+                             `"level":${value},"levelName":${nameJSON}`);
+}
+
+// Built-in level -> SerializedLevel.
+const serializedLevels = new SafeMap();
+for (let i = 0; i < kLevelNames.length; i++) {
+  const level = levels[kLevelNames[i]];
+  serializedLevels.set(level, serializeLevel(level.name, level.value));
+}
+
+function joinFields(a, b) {
+  if (a === '') return b;
+  if (b === '') return a;
+  return `${a},${b}`;
+}
+
+/**
+ * Returns the line (what defaultSerializer() would produce for the record
+ * ConsoleProvider creates from `event`, followed by a newline), or undefined
+ * if the generic path must be used.
+ * @param {object} event
+ * @param {object} [context] The context passed to the provider.
+ * @param {boolean} flatten
+ * @param {string} pidJSON `,"pid":<pid>` if enabled, otherwise ''.
+ * @returns {string|undefined}
+ */
+function serializeEventFast(event, context, flatten, pidJSON) {
+  if (!isLogEvent(event)) return undefined;
+  const { attributes, bindings, level, message, name, timestamp } = event;
+  if (typeof attributes !== 'object' || attributes === null ||
+      typeof bindings !== 'object' || bindings === null ||
+      typeof level !== 'object' || level === null ||
+      typeof timestamp !== 'number') {
+    return undefined;
+  }
+  let serializedLevel = serializedLevels.get(level);
+  if (serializedLevel === undefined) {
+    const levelName = level.name;
+    const levelValue = level.value;
+    if (typeof levelName !== 'string' || !NumberIsFinite(levelValue)) {
+      return undefined;
+    }
+    serializedLevel = serializeLevel(levelName, levelValue);
+  }
+  const messageJSON = serializeValue(message, 0);
+  if (messageJSON === kGeneric) return undefined;
+  if (name !== undefined && typeof name !== 'string') return undefined;
+
+  const serializedBindings = getSerializedBindings(bindings, name, context);
+  if (serializedBindings.fields === kGeneric) return undefined;
+
+  if (timestamp !== lastTimestamp) {
+    lastTimestamp = timestamp;
+    lastTimestampJSON = `${timestamp}`;
+  }
+  const tail =
+    `${messageJSON === undefined ? '' : `,"message":${messageJSON}`}` +
+    `${serializedBindings.nameFragment},"timestamp":${lastTimestampJSON}` +
+    `${pidJSON}}\n`;
+
+  if (flatten) {
+    if (!serializedBindings.flatSafe) return undefined;
+    const attributeFields = serializeFields(attributes, true, bindings);
+    if (attributeFields === kGeneric) return undefined;
+    const fields = joinFields(serializedBindings.fields, attributeFields);
+    return `{${fields === '' ? '' : `${fields},`}${serializedLevel.flat}` +
+      tail;
+  }
+
+  const attributeFields = serializeFields(attributes, true);
+  if (attributeFields === kGeneric) return undefined;
+  return `{"attributes":{${attributeFields}},` +
+    `"bindings":{${serializedBindings.fields}},` +
+    `"level":${serializedLevel.nested}${tail}`;
+}
+
+/**
+ * A provider that fans log events out to multiple providers.
+ */
+class AggregateProvider {
+  #dispatchable;
+  #providers;
+
+  static {
+    aggregateIsEnabled = this.prototype.isEnabled;
+    isAggregateDispatchable = (provider) => {
+      return #dispatchable in provider && provider.#dispatchable;
+    };
+  }
+
+  constructor(providers) {
+    validateArray(providers, 'providers');
+    const copy = ArrayPrototypeSlice(providers);
+    let dispatchable = true;
+    for (let i = 0; i < copy.length; i++) {
+      validateProvider(copy[i], `providers[${i}]`);
+      dispatchable &&= isDispatchable(copy[i]);
+    }
+    this.#providers = ObjectFreeze(copy);
+    this.#dispatchable = dispatchable;
+
+    if (dispatchable) {
+      // Re-resolve loggers using this aggregate whenever a member's
+      // enablement changes. Members without isEnabled() never change.
+      let ref;
+      for (let i = 0; i < copy.length; i++) {
+        const provider = copy[i];
+        if (provider.isEnabled === undefined) continue;
+        ref ??= new SafeWeakRef(this);
+        // Duplicate members share the ref, so the SafeSet dedupes them.
+        getDispatchState(provider).dependents.add(ref);
+      }
+    }
+  }
+
+  get providers() {
+    return this.#providers;
+  }
+
+  isEnabled(level, context) {
+    for (let i = 0; i < this.#providers.length; i++) {
+      if (isProviderEnabled(this.#providers[i], level, context)) return true;
+    }
+    return false;
+  }
+
+  log(event, context) {
+    for (let i = 0; i < this.#providers.length; i++) {
+      const provider = this.#providers[i];
+      if (isProviderEnabled(provider, event.level, context)) {
+        FunctionPrototypeCall(provider.log, provider, event, context);
+      }
+    }
+  }
+}
+
+/**
+ * A provider that writes newline-delimited JSON to stdout or stderr.
+ */
+class ConsoleProvider {
+  #destination;
+  #flatten;
+  #level;
+  #pid;
+  #pidJSON;
+  #serializer;
+  #stream;
+
+  static {
+    kObservableIsEnabled.add(this.prototype.isEnabled);
+  }
+
+  constructor(options = kEmptyObject) {
+    validateObject(options, 'options');
+    const {
+      destination = 'stdout',
+      flatten = false,
+      level = 'info',
+      maxLength,
+      minLength,
+      periodicFlush,
+      pid = false,
+      serializer = defaultSerializer,
+      sync,
+    } = options;
+
+    validateOneOf(destination, 'options.destination', kDestinations);
+    validateBoolean(flatten, 'options.flatten');
+    validateBoolean(pid, 'options.pid');
+    validateFunction(serializer, 'options.serializer');
+    this.#destination = destination;
+    this.#flatten = flatten;
+    this.#level = normalizeThreshold(level, 'options.level');
+    this.#pid = pid;
+    this.#pidJSON = pid ? `,"pid":${process.pid}` : '';
+    this.#serializer = serializer;
+    this.#stream = new Utf8Stream({
+      // Creating the logger is not a hotpath... it's ok for the options
+      // to be passed in dictionary mode rather than fast properties mode.
+      __proto__: null,
+      fd: destination === 'stdout' ? 1 : 2,
+      maxLength,
+      minLength,
+      periodicFlush,
+      sync,
+    });
+  }
+
+  get destination() {
+    return this.#destination;
+  }
+
+  get flatten() {
+    return this.#flatten;
+  }
+
+  get level() {
+    return this.#level;
+  }
+
+  set level(level) {
+    this.#level = normalizeThreshold(level);
+    invalidateDispatch(this);
+  }
+
+  get pid() {
+    return this.#pid;
+  }
+
+  get serializer() {
+    return this.#serializer;
+  }
+
+  get stream() {
+    return this.#stream;
+  }
+
+  isEnabled(level) {
+    return level.value >= this.#level.value;
+  }
+
+  log(event, context) {
+    if (this.isEnabled(event.level)) {
+      if (this.#serializer === defaultSerializer) {
+        const serialized =
+          serializeEventFast(event, context, this.#flatten, this.#pidJSON);
+        if (serialized !== undefined) {
+          this.#stream.write(serialized);
+          return;
+        }
+      }
+      let record = event;
+      if (this.#flatten || this.#pid) {
+        const withPid = this.#pid ? { pid: process.pid } : null;
+        record = new NullPrototypeObject();
+        if (this.#flatten) {
+          record = ObjectAssign(
+            record,
+            event.bindings,
+            event.attributes,
+            {
+              level: event.level.value,
+              levelName: event.level.name,
+              message: event.message,
+              name: event.name,
+              timestamp: event.timestamp,
+            },
+            withPid,
+          );
+        } else {
+          record = ObjectAssign(record, event, withPid);
+        }
+      }
+      const serialized = FunctionPrototypeCall(
+        this.#serializer,
+        undefined,
+        record,
+      );
+      if (typeof serialized !== 'string') {
+        throw new ERR_INVALID_RETURN_VALUE(
+          'a string',
+          'serializer',
+          serialized,
+        );
+      }
+      this.#stream.write(`${serialized}\n`);
+    }
+  }
+
+  flush(callback) {
+    this.#stream.flush(callback);
+  }
+
+  flushSync() {
+    this.#stream.flushSync();
+  }
+}
+
+/**
+ * A provider that publishes log events to diagnostics channels.
+ */
+class DiagnosticsProvider {
+  #router;
+  #routes;
+
+  constructor(channels) {
+    if (typeof channels === 'function') {
+      this.#router = channels;
+      return;
+    }
+
+    validateObject(channels, 'channels');
+    const names = ReflectOwnKeys(channels);
+    const routes = [];
+    for (let i = 0; i < names.length; i++) {
+      const name = names[i];
+      const selector = channels[name];
+      validateFunction(selector, `channels[${i}]`);
+      const obj = {
+        channel: diagnosticsChannel(name),
+        selector,
+      };
+      ObjectSetPrototypeOf(obj, null);
+      ArrayPrototypePush(routes, obj);
+    }
+    this.#routes = routes;
+  }
+
+  isEnabled(level) {
+    if (this.#router !== undefined) {
+      const channel = this.#getChannel(level);
+      return channel?.hasSubscribers === true;
+    }
+
+    for (let i = 0; i < this.#routes.length; i++) {
+      const route = this.#routes[i];
+      if (route.channel.hasSubscribers &&
+          FunctionPrototypeCall(route.selector, undefined, level)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  log(event) {
+    if (this.#router !== undefined) {
+      const channel = this.#getChannel(event.level);
+      if (channel?.hasSubscribers) channel.publish(event);
+      return;
+    }
+
+    for (let i = 0; i < this.#routes.length; i++) {
+      const route = this.#routes[i];
+      if (route.channel.hasSubscribers &&
+          FunctionPrototypeCall(route.selector, undefined, event.level)) {
+        route.channel.publish(event);
+      }
+    }
+  }
+
+  #getChannel(level) {
+    const name = FunctionPrototypeCall(this.#router, undefined, level);
+    return name === undefined ? undefined : diagnosticsChannel(name);
+  }
+}
+
+/**
+ * An EventEmitter that receives structured log events.
+ */
+class EventProvider extends EventEmitter {
+  #level;
+
+  static {
+    kObservableIsEnabled.add(this.prototype.isEnabled);
+  }
+
+  constructor(options = kEmptyObject) {
+    validateObject(options, 'options');
+    const { level = 'trace' } = options;
+    const normalizedLevel = normalizeThreshold(level, 'options.level');
+
+    super();
+    this.#level = normalizedLevel;
+  }
+
+  get level() {
+    return this.#level;
+  }
+
+  set level(level) {
+    this.#level = normalizeThreshold(level);
+    invalidateDispatch(this);
+  }
+
+  isEnabled(level) {
+    return level.value >= this.#level.value;
+  }
+
+  log(event) {
+    if (this.isEnabled(event.level)) {
+      const eventName = event.level.name;
+      this.emit(this.listenerCount(eventName) > 0 ? eventName : 'log', event);
+    }
+  }
+}
+
+let isLogger;
+
+// Passed as the first constructor argument by child(), which has already
+// validated its arguments, copied the bindings, and allocates the child with
+// the right prototype. Not reachable by users.
+const kLoggerInit = Symbol('kLoggerInit');
+
+function LoggerInit(provider, name, bindings, childTarget, parentContext) {
+  this.provider = provider;
+  this.name = name;
+  this.bindings = bindings;
+  this.childTarget = childTarget;
+  this.parentContext = parentContext;
+}
+LoggerInit.prototype = kNullPrototype;
+
+class Logger {
+  #bindings;
+  // The class child() uses to allocate children with the provider's dispatch
+  // prototype: undefined until first needed, null if there is none.
+  #childTarget;
+  #context;
+  // Whether any binding is a function, or undefined until #materialize().
+  #hasFunction;
+  #name;
+  #provider;
+
+  static {
+    isLogger = (obj) => {
+      return obj !== null && typeof obj === 'object' && #provider in obj;
+    };
+  }
+
+  constructor(providerOrOptions, options) {
+    if (providerOrOptions === kLoggerInit) {
+      // Internal (child()): already validated, bindings already copied, and
+      // allocated with the right prototype. Freezing the bindings and looking
+      // for functions in them is deferred (see #materialize()).
+      this.#init(options.provider, options.name, options.bindings,
+                 undefined, options.parentContext);
+      this.#childTarget = options.childTarget;
+      return;
+    }
+
+    emitExperimentalWarning('Logger');
+
+    let provider = providerOrOptions;
+    if (provider == null) {
+      provider = getDefaultProvider();
+    } else if (options === undefined &&
+               typeof provider === 'object' &&
+               !isProvider(provider)) {
+      options = provider;
+      provider = getDefaultProvider();
+    }
+
+    options ??= kEmptyObject;
+    validateProvider(provider);
+    validateObject(options, 'options');
+
+    const {
+      bindings = kEmptyBindings,
+      name,
+    } = options;
+    validateObject(bindings, 'options.bindings');
+    if (name !== undefined) {
+      validateString(name, 'options.name');
+    }
+
+    // Frozen, since the same object is passed as event.bindings for every
+    // event when no binding is a function.
+    const copy = ObjectFreeze(copyObject(bindings));
+    this.#init(provider, name, copy, hasFunction(copy));
+
+    // Interpose the shared dispatch prototype so that methods for disabled
+    // levels resolve to an empty function. create() and child() allocate
+    // loggers with it already in place (see constructLogger()). Otherwise,
+    // e.g. for `new Logger()` and subclasses, it is swapped in here, using
+    // the current prototype as the base so that subclasses keep their own
+    // methods.
+    const proto = ObjectGetPrototypeOf(this);
+    const info = dispatchInfo.get(proto);
+    if (info?.provider !== provider) {
+      // A dispatch prototype belonging to another provider (only reachable
+      // via a crafted new.target) is replaced, starting from its base.
+      const base = info === undefined ? proto : info.base;
+      const dispatch = getDispatchPrototype(provider, base) ?? base;
+      if (dispatch !== proto) {
+        ObjectSetPrototypeOf(this, dispatch);
+      }
+    }
+  }
+
+  #init(provider, name, bindings, hasFunction, parentContext) {
+    this.#provider = provider;
+    this.#name = name;
+    this.#bindings = bindings;
+    this.#hasFunction = hasFunction;
+    this.#context = new LoggerContext(bindings, name, parentContext);
+  }
+
+  get provider() {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    return this.#provider;
+  }
+
+  get name() {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    return this.#name;
+  }
+
+  get bindings() {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    if (this.#hasFunction === undefined) this.#materialize();
+    return this.#bindings;
+  }
+
+  isEnabled(level) {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    return this.#isEnabled(normalizeLevel(level));
+  }
+
+  log(level, message, attributes = kEmptyAttributes) {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    this.#log(normalizeLevel(level), message, attributes);
+  }
+
+  trace(message, attributes = kEmptyAttributes) {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    this.#log(levels.trace, message, attributes);
+  }
+
+  debug(message, attributes = kEmptyAttributes) {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    this.#log(levels.debug, message, attributes);
+  }
+
+  info(message, attributes = kEmptyAttributes) {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    this.#log(levels.info, message, attributes);
+  }
+
+  warn(message, attributes = kEmptyAttributes) {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    this.#log(levels.warn, message, attributes);
+  }
+
+  error(message, attributes = kEmptyAttributes) {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    this.#log(levels.error, message, attributes);
+  }
+
+  fatal(message, attributes = kEmptyAttributes) {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    this.#log(levels.fatal, message, attributes);
+  }
+
+  child(bindings, options = kEmptyObject) {
+    if (!isLogger(this)) {
+      throw new ERR_INVALID_THIS('Logger');
+    }
+    validateObject(bindings, 'bindings');
+    validateObject(options, 'options');
+
+    const { name = this.#name } = options;
+    if (name !== undefined) {
+      validateString(name, 'options.name');
+    }
+
+    // Children share the provider, so they also share the class that
+    // allocates them with its dispatch prototype. Resolved once per parent
+    // and passed down to children.
+    let childTarget = this.#childTarget;
+    if (childTarget === undefined) {
+      const dispatch = getDispatchPrototype(this.#provider, Logger.prototype);
+      childTarget = dispatch === undefined ?
+        null : dispatchInfo.get(dispatch).target;
+      this.#childTarget = childTarget;
+    }
+
+    // Not frozen yet: many children never log (e.g. only disabled levels),
+    // so that is deferred until the bindings are observable. Nothing else can
+    // reach them before then, so they cannot change meanwhile.
+    const init = new LoggerInit(
+      this.#provider,
+      name,
+      ObjectAssign(new NullPrototypeObject(), this.#bindings, bindings),
+      childTarget,
+      this.#context,
+    );
+    return childTarget === null ?
+      new Logger(kLoggerInit, init) :
+      new childTarget(kLoggerInit, init);
+  }
+
+  // Completes the setup that child() defers. Called before the bindings
+  // become observable: through the bindings getter, or through the context
+  // passed to the provider (every call to the provider goes through
+  // #isEnabled()).
+  #materialize() {
+    ObjectFreeze(this.#bindings);
+    this.#hasFunction = hasFunction(this.#bindings);
+  }
+
+  #isEnabled(level) {
+    if (this.#hasFunction === undefined) this.#materialize();
+    return isProviderEnabled(this.#provider, level, this.#context);
+  }
+
+  #log(level, message, attributes) {
+    if (!this.#isEnabled(level)) {
+      return;
+    }
+
+    validateObject(attributes, 'attributes');
+
+    const event = new LogEvent(
+      attributes === kEmptyAttributes ?
+        attributes : copyObject(attributes, true),
+      this.#hasFunction ? copyObject(this.#bindings, true) : this.#bindings,
+      level,
+      message,
+      this.#name,
+      DateNow(),
+    );
+
+    FunctionPrototypeCall(
+      this.#provider.log,
+      this.#provider,
+      event,
+      this.#context,
+    );
+  }
+}
+
+createDispatchClass = (base) => {
+  if (base !== Logger.prototype) return undefined;
+  // Uses the default derived constructor, which V8 skips entirely.
+  const DispatchLogger = class extends Logger {};
+  ObjectDefineProperty(DispatchLogger.prototype, 'constructor', {
+    __proto__: null,
+    configurable: true,
+    enumerable: false,
+    value: Logger,
+    writable: true,
+  });
+  return DispatchLogger;
+};
+
+kLevelMethods = {};
+ObjectSetPrototypeOf(kLevelMethods, null);
+for (let i = 0; i < kLevelNames.length; i++) {
+  const name = kLevelNames[i];
+  kLevelMethods[name] = Logger.prototype[name];
+}
+
+/**
+ * Creates a Logger whose prototype is the provider's dispatch prototype from
+ * the start, if it has one. Equivalent to `new Logger(...)`, which instead
+ * has to swap the prototype after allocation.
+ * @param {any} providerOrOptions
+ * @param {object} [options]
+ * @returns {Logger}
+ */
+function constructLogger(providerOrOptions, options) {
+  // Resolve the provider the same way the constructor does, without
+  // validating. Anything the constructor would reject goes through the
+  // regular path so that errors are reported identically.
+  let provider = providerOrOptions;
+  if (provider == null ||
+      (options === undefined && typeof provider === 'object' &&
+       !isProvider(provider))) {
+    provider = getDefaultProvider();
+  }
+  if (isProvider(provider)) {
+    const dispatch = getDispatchPrototype(provider, Logger.prototype);
+    if (dispatch !== undefined) {
+      const DispatchLogger = dispatchInfo.get(dispatch).target;
+      return new DispatchLogger(providerOrOptions, options);
+    }
+  }
+  return new Logger(providerOrOptions, options);
+}
+
+function create(provider, options) {
+  return constructLogger(provider, options);
+}
+
+let defaultProvider;
+
+function getDefaultProvider() {
+  defaultProvider ??= new ConsoleProvider();
+  return defaultProvider;
+}
+
+let settingDefaultProvider = false;
+
+function setDefaultProvider(provider) {
+  if (settingDefaultProvider) {
+    throw new ERR_INVALID_STATE('Already setting the default provider');
+  }
+  settingDefaultProvider = true;
+  try {
+    // Note that we validate the provider after the settingDefaultProvider
+    // check. That is to prevent re-entrant calls that might happen when
+    // we try to access the properties of the provider that is given.
+    validateProvider(provider, 'defaultProvider');
+    if (provider !== defaultProvider &&
+      process.listenerCount('defaultLoggerProviderChanged')) {
+      process.emit('defaultLoggerProviderChanged', provider, defaultProvider);
+    }
+    defaultProvider = provider;
+  } finally {
+    settingDefaultProvider = false;
+  }
+}
+
+function getDescriptor(value) {
+  const desc = {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true,
+  };
+  ObjectSetPrototypeOf(desc, null);
+  return desc;
+}
+
+const properties = {
+  AggregateProvider: getDescriptor(AggregateProvider),
+  ConsoleProvider: getDescriptor(ConsoleProvider),
+  DiagnosticsProvider: getDescriptor(DiagnosticsProvider),
+  EventProvider: getDescriptor(EventProvider),
+  Logger: getDescriptor(Logger),
+  create: getDescriptor(create),
+  getDefaultProvider: getDescriptor(getDefaultProvider),
+  levels: getDescriptor(levels),
+  setDefaultProvider: getDescriptor(setDefaultProvider),
+};
+ObjectSetPrototypeOf(properties, null);
+ObjectDefineProperties(create, properties);
+
+module.exports = create;
diff --git a/src/node_builtins.cc b/src/node_builtins.cc
index 21af988c95d8..210fe63cc2e2 100644
--- a/src/node_builtins.cc
+++ b/src/node_builtins.cc
@@ -162,6 +162,7 @@ BuiltinLoader::BuiltinCategories BuiltinLoader::GetBuiltinCategories() const {
         "bench/reporters",  // Experimental.
         "dtls",             // Experimental.
         "ffi",              // Experimental.
+        "logger",           // Experimental.
         "quic",             // Experimental.
         "sqlite",           // Experimental.
         "stream/iter",      // Experimental.
diff --git a/src/node_options.cc b/src/node_options.cc
index 917f6a4f47cc..ae791f6a74b1 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -773,6 +773,10 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             kAllowedInEnvvar,
             HAVE_FFI);
 #endif  // HAVE_FFI
+  AddOption("--experimental-logger",
+            "experimental node:logger module",
+            BOOL_FIELD(experimental_logger),
+            kAllowedInEnvvar);
   AddOption("--experimental-web-worker",
             "experimental Web Worker API",
             BOOL_FIELD(experimental_web_worker),
diff --git a/src/node_options.h b/src/node_options.h
index 78de1111ce9a..44967eca6394 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -211,6 +211,7 @@ class EnvironmentOptions : public Options {
   DEFINE_BOOL_FIELD(experimental_bench) = EXPERIMENTALS_DEFAULT_VALUE;
   DEFINE_BOOL_FIELD(experimental_eventsource) = EXPERIMENTALS_DEFAULT_VALUE;
   DEFINE_BOOL_FIELD(experimental_ffi) = HAVE_FFI;
+  DEFINE_BOOL_FIELD(experimental_logger) = EXPERIMENTALS_DEFAULT_VALUE;
   DEFINE_BOOL_FIELD(experimental_web_worker) = EXPERIMENTALS_DEFAULT_VALUE;
   DEFINE_BOOL_FIELD(experimental_websocket) = true;
   DEFINE_BOOL_FIELD(experimental_sqlite) = HAVE_SQLITE;
diff --git a/test/benchmark/test-benchmark-logger.js b/test/benchmark/test-benchmark-logger.js
new file mode 100644
index 000000000000..b7252e3822e5
--- /dev/null
+++ b/test/benchmark/test-benchmark-logger.js
@@ -0,0 +1,7 @@
+'use strict';
+
+require('../common');
+
+const runBenchmark = require('../common/benchmark');
+
+runBenchmark('logger', { NODEJS_BENCHMARK_ZERO_ALLOWED: 1 });
diff --git a/test/module-hooks/test-module-hooks-builtin-require.js b/test/module-hooks/test-module-hooks-builtin-require.js
index 0ee8de756116..54f9e8aa347a 100644
--- a/test/module-hooks/test-module-hooks-builtin-require.js
+++ b/test/module-hooks/test-module-hooks-builtin-require.js
@@ -1,4 +1,4 @@
-// Flags: --experimental-bench --no-warnings
+// Flags: --experimental-logger --experimental-bench --no-warnings
 'use strict';
 
 // This tests that when builtins that demand the `node:` prefix are
@@ -14,6 +14,7 @@ const { registerHooks } = require('module');
 const schemelessBlockList = new Set([
   'bench',
   'bench/reporters',
+  'logger',
   'sea',
   'test',
   'test/reporters',
diff --git a/test/module-hooks/test-module-hooks-load-builtin-require.js b/test/module-hooks/test-module-hooks-load-builtin-require.js
index d86eb4b9df76..b38bec4021c4 100644
--- a/test/module-hooks/test-module-hooks-load-builtin-require.js
+++ b/test/module-hooks/test-module-hooks-load-builtin-require.js
@@ -1,4 +1,4 @@
-// Flags: --experimental-bench --no-warnings
+// Flags: --experimental-logger --experimental-bench --no-warnings
 'use strict';
 
 const common = require('../common');
@@ -38,6 +38,7 @@ hook.deregister();
 const schemelessBlockList = new Set([
   'bench',
   'bench/reporters',
+  'logger',
   'sea',
   'test',
   'test/reporters',
diff --git a/test/parallel/test-logger-console-provider-serialization.js b/test/parallel/test-logger-console-provider-serialization.js
new file mode 100644
index 000000000000..5effeae109df
--- /dev/null
+++ b/test/parallel/test-logger-console-provider-serialization.js
@@ -0,0 +1,192 @@
+// Flags: --experimental-logger --no-warnings
+
+'use strict';
+
+// ConsoleProvider serializes events created by Logger without going through
+// the configured serializer when it is the default one. Check that the output
+// is identical to the default serializer's output for the same record.
+
+require('../common');
+const assert = require('node:assert');
+const { AsyncLocalStorage } = require('node:async_hooks');
+const {
+  AggregateProvider,
+  ConsoleProvider,
+  create,
+  levels,
+} = require('node:logger');
+
+function capture(provider) {
+  const lines = [];
+  provider.stream.write = (data) => {
+    lines.push(data);
+    return true;
+  };
+  return lines;
+}
+
+const als = new AsyncLocalStorage();
+
+const err = new Error('boom');
+err.code = 'E_BOOM';
+
+function makeError(message, props) {
+  return Object.assign(new Error(message), props);
+}
+
+const selfCause = new Error('self');
+selfCause.cause = selfCause;
+
+let deepCause = new Error('bottom');
+for (let i = 0; i < 12; i++) deepCause = new Error(`level ${i}`, { cause: deepCause });
+
+const enumerableMessage = new Error('hidden');
+Object.defineProperty(enumerableMessage, 'message', {
+  value: 'visible "message"', enumerable: true,
+});
+
+const noStack = new Error('no stack');
+delete noStack.stack;
+
+class CustomError extends Error {
+  get name() { return 'CustomError'; }
+}
+
+const errorVariants = [
+  err,
+  new TypeError('type \n error'),
+  new Error('with cause', { cause: new Error('inner', { cause: 'root' }) }),
+  new Error('string cause', { cause: 'just a string' }),
+  selfCause,
+  deepCause,
+  enumerableMessage,
+  makeError('props', { status: 500, retry: true, extra: undefined }),
+  makeError('nested', { inner: new RangeError('nested error') }),
+  makeError('object prop', { details: { a: 1 } }),
+  makeError('index key', { 0: 'zero' }),
+  makeError('code', { code: 42 }),
+  makeError('toJSON', { toJSON() { return 'custom'; } }),
+  new AggregateError([new Error('a')], 'aggregate'),
+  noStack,
+  new CustomError('custom'),
+];
+
+const bindingVariants = [
+  undefined,
+  { service: 'api', port: 3000, on: true, none: null, skip: undefined },
+  { request: () => als.getStore(), service: 'api' },
+  { 1: 'index', service: 'api' },
+  { level: 'binding level' },
+  { pid: 'binding pid' },
+  { nested: { a: 1 } },
+  { big: 1n },
+  { err },
+];
+
+const attributeVariants = [
+  undefined,
+  {},
+  { i: 1, user: 'x' },
+  { text: 'quote " backslash \\ newline \n tab \t \u2028 \ud800 \u{1F600}' },
+  { nan: NaN, inf: -Infinity, negZero: -0, big: 1.5e300, small: 5e-324 },
+  { yes: true, no: false, nothing: null, missing: undefined },
+  { fn: () => 'resolved', fnObject: () => ({ a: 1 }) },
+  { sym: Symbol('value'), [Symbol('key')]: 'symbol key' },
+  { 2: 'index', a: 1 },
+  { service: 'attribute service' },
+  { level: 1, levelName: 2, message: 3, name: 4, pid: 5, timestamp: 6 },
+  { nested: { a: [1, 2, { b: 'c' }] } },
+  { err },
+  { big: 10n },
+  { date: new Date(0) },
+  { list: [1, 'two', null] },
+  { '': 'empty key', 'k"ey': 'quoted key' },
+  { long: 'x'.repeat(100), longEscaped: `${'y'.repeat(100)}"` },
+  { emoji: '\u{1F600}', [`key\n${'z'.repeat(70)}`]: 1 },
+  ...errorVariants.map((error) => ({ error, after: 1 })),
+];
+
+const messages = [
+  'hello',
+  '',
+  undefined,
+  42,
+  null,
+  true,
+  { object: 'message' },
+  Symbol('message'),
+  () => {},
+  ...errorVariants,
+];
+
+// Child bindings, whose serialization extends the parent's when possible.
+const childBindingVariants = [
+  {},
+  { child: true },
+  { service: 'override' },
+  { service: 'api' },
+  { 3: 'index' },
+  { level: 'child level' },
+  { skip: undefined, after: 'x' },
+  { nested: { a: 1 } },
+  { childFn: () => 'child fn' },
+];
+
+let compared = 0;
+for (const flatten of [false, true]) {
+  for (const pid of [false, true]) {
+    const fast = new ConsoleProvider({ flatten, pid, level: 'trace' });
+    const generic = new ConsoleProvider({
+      flatten,
+      pid,
+      level: 'trace',
+      // Any serializer other than the default one disables the fast path.
+      serializer: (record) => fast.serializer(record),
+    });
+    const fastLines = capture(fast);
+    const genericLines = capture(generic);
+    const aggregate = new AggregateProvider([fast, generic]);
+    // Forwards events without the context.
+    const wrapper = { log(event) { aggregate.log(event); } };
+
+    for (const bindings of bindingVariants) {
+      for (const [name, provider] of [[undefined, aggregate],
+                                      ['logger "name"', aggregate],
+                                      ['wrapped', wrapper]]) {
+        const logger = create(provider, { name, bindings });
+        als.run({ requestId: 1 }, () => {
+          for (const attributes of attributeVariants) {
+            for (const message of messages) {
+              if (attributes === undefined) {
+                logger.info(message);
+              } else {
+                logger.info(message, attributes);
+              }
+            }
+          }
+          logger.log({ name: 'custom "level"', value: 35 }, 'custom');
+          for (const childBindings of childBindingVariants) {
+            const child = logger.child(childBindings);
+            const grandchild = child.child({ grandchild: 1 });
+            // The grandchild logs first, before its parent ever has.
+            for (let i = 0; i < 2; i++) {
+              grandchild.warn('from grandchild', { i });
+              child.warn('from child', { i });
+            }
+          }
+        });
+      }
+    }
+
+    // Objects passed to the provider directly are not Logger events.
+    aggregate.log({ level: levels.info, message: 'direct', extra: 1 });
+
+    assert.strictEqual(fastLines.length, genericLines.length);
+    for (let i = 0; i < fastLines.length; i++) {
+      assert.strictEqual(fastLines[i], genericLines[i],
+                         `flatten=${flatten} pid=${pid} line ${i}`);
+    }
+    compared += fastLines.length;
+  }
+}
+assert.ok(compared > 0);
diff --git a/test/parallel/test-logger-console-provider.js b/test/parallel/test-logger-console-provider.js
new file mode 100644
index 000000000000..a2466f6bb66b
--- /dev/null
+++ b/test/parallel/test-logger-console-provider.js
@@ -0,0 +1,278 @@
+// Flags: --experimental-logger
+
+'use strict';
+
+require('../common');
+const assert = require('node:assert');
+const { spawnSync } = require('node:child_process');
+const { ConsoleProvider, levels } = require('node:logger');
+const { inspect } = require('node:util');
+
+function run(destination, level, statement, options = {}) {
+  const script = `
+    const { ConsoleProvider, create } = require('node:logger');
+    const provider = new ConsoleProvider({
+      destination: ${JSON.stringify(destination)},
+      level: ${JSON.stringify(level)},
+      sync: true,
+      ...${JSON.stringify(options)},
+    });
+    const logger = create(provider, {
+      name: 'example',
+      bindings: { service: 'api' },
+    });
+    ${statement}
+    provider.flushSync();
+  `;
+
+  return spawnSync(process.execPath, [
+    '--experimental-logger',
+    '--no-warnings',
+    '-e',
+    script,
+  ], {
+    encoding: 'utf8',
+  });
+}
+
+{
+  const result = run(
+    'stdout',
+    'debug',
+    "logger.trace('filtered'); logger.info('started', { port: 3000 });",
+  );
+
+  assert.strictEqual(result.status, 0);
+  assert.strictEqual(result.stderr, '');
+  const event = JSON.parse(result.stdout);
+  assert.strictEqual(event.message, 'started');
+  assert.strictEqual(event.name, 'example');
+  assert.deepStrictEqual(event.level, { name: 'info', value: 30 });
+  assert.deepStrictEqual(event.bindings, { service: 'api' });
+  assert.deepStrictEqual(event.attributes, { port: 3000 });
+  assert.strictEqual(typeof event.timestamp, 'number');
+  assert.strictEqual('pid' in event, false);
+}
+
+{
+  const result = run(
+    'stdout',
+    'info',
+    `
+      logger.info('flattened', {
+        level: 'attribute level',
+        levelName: 'attribute name',
+        message: 'attribute message',
+        name: 'attribute name',
+        pid: -1,
+        requestId: 1,
+        service: 'worker',
+        timestamp: 0,
+      });
+    `,
+    { flatten: true, pid: true },
+  );
+
+  assert.strictEqual(result.status, 0);
+  assert.strictEqual(result.stderr, '');
+  const event = JSON.parse(result.stdout);
+  assert.strictEqual('attributes' in event, false);
+  assert.strictEqual('bindings' in event, false);
+  assert.strictEqual(event.level, 30);
+  assert.strictEqual(event.levelName, 'info');
+  assert.strictEqual(event.message, 'flattened');
+  assert.strictEqual(event.name, 'example');
+  assert.ok(event.pid > 0);
+  assert.strictEqual(event.requestId, 1);
+  assert.strictEqual(event.service, 'worker');
+  assert.ok(event.timestamp > 0);
+}
+
+{
+  // When the pid option is disabled, a flattened `pid` attribute must be
+  // preserved rather than overwritten.
+  const result = run(
+    'stdout',
+    'info',
+    "logger.info('flattened', { pid: 'attribute pid' });",
+    { flatten: true },
+  );
+
+  assert.strictEqual(result.status, 0);
+  assert.strictEqual(result.stderr, '');
+  const event = JSON.parse(result.stdout);
+  assert.strictEqual(event.pid, 'attribute pid');
+}
+
+{
+  const script = `
+    const { ConsoleProvider, create } = require('node:logger');
+    const provider = new ConsoleProvider({ pid: true, sync: true });
+    const logger = create(provider);
+    logger.info('with pid');
+    provider.flushSync();
+  `;
+  const result = spawnSync(process.execPath, [
+    '--experimental-logger',
+    '--no-warnings',
+    '-e',
+    script,
+  ], { encoding: 'utf8' });
+
+  assert.strictEqual(result.status, 0);
+  assert.strictEqual(result.stderr, '');
+  const event = JSON.parse(result.stdout);
+  assert.strictEqual(event.message, 'with pid');
+  assert.ok(Number.isInteger(event.pid));
+  assert.ok(event.pid > 0);
+}
+
+{
+  const result = run(
+    'stderr',
+    'error',
+    "logger.warn('filtered'); logger.error('failed');",
+  );
+
+  assert.strictEqual(result.status, 0);
+  assert.strictEqual(result.stdout, '');
+  const event = JSON.parse(result.stderr);
+  assert.strictEqual(event.message, 'failed');
+  assert.deepStrictEqual(event.level, { name: 'error', value: 50 });
+}
+
+{
+  const result = run(
+    'stdout',
+    'trace',
+    `
+      const shared = { value: 1 };
+      const message = {
+        bigint: 9007199254740993n,
+        error: Object.assign(new Error('boom'), { code: 'ERR_TEST' }),
+        first: shared,
+        second: shared,
+      };
+      message.self = message;
+      logger.info(message);
+    `,
+  );
+
+  assert.strictEqual(result.status, 0);
+  assert.strictEqual(result.stderr, '');
+  const event = JSON.parse(result.stdout);
+  assert.strictEqual(event.message.bigint, '9007199254740993');
+  assert.strictEqual(event.message.error.name, 'Error');
+  assert.strictEqual(event.message.error.message, 'boom');
+  assert.match(event.message.error.stack, /^Error: boom/);
+  assert.strictEqual(event.message.error.code, 'ERR_TEST');
+  assert.deepStrictEqual(event.message.first, { value: 1 });
+  assert.deepStrictEqual(event.message.second, { value: 1 });
+  assert.strictEqual(event.message.self, '[Circular]');
+}
+
+{
+  const script = `
+    const { ConsoleProvider, create } = require('node:logger');
+    const { inspect } = require('node:util');
+    const provider = new ConsoleProvider({ serializer: inspect, sync: true });
+    const logger = create(provider);
+    const cyclic = { value: 1n };
+    cyclic.self = cyclic;
+    logger.info('inspected', { cyclic });
+    provider.flushSync();
+  `;
+  const result = spawnSync(process.execPath, [
+    '--experimental-logger',
+    '--no-warnings',
+    '-e',
+    script,
+  ], { encoding: 'utf8' });
+
+  assert.strictEqual(result.status, 0);
+  assert.strictEqual(result.stderr, '');
+  assert.match(result.stdout, /message: 'inspected'/);
+  assert.match(result.stdout, /value: 1n/);
+  assert.match(result.stdout, /\[Circular \*\d+\]/);
+}
+
+{
+  const provider = new ConsoleProvider({ flatten: true, serializer: inspect });
+  assert.strictEqual(provider.flatten, true);
+  assert.strictEqual(provider.serializer, inspect);
+
+  provider.level = 'warn';
+  assert.strictEqual(provider.level, levels.warn);
+
+  const customLevel = { name: 'notice', value: 35 };
+  provider.level = customLevel;
+  customLevel.value = 0;
+  assert.strictEqual(provider.level.name, 'notice');
+  assert.strictEqual(provider.level.value, 35);
+  assert.strictEqual(Object.isFrozen(provider.level), true);
+}
+
+assert.throws(
+  () => new ConsoleProvider({ serializer: 'json' }),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+assert.throws(
+  () => new ConsoleProvider({ flatten: 1 }),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+assert.throws(
+  () => new ConsoleProvider({ pid: 1 }),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+
+{
+  const provider = new ConsoleProvider();
+  assert.throws(
+    () => { provider.level = 'unknown'; },
+    { code: 'ERR_INVALID_ARG_VALUE' },
+  );
+}
+
+{
+  const provider = new ConsoleProvider({ serializer: () => null });
+  assert.throws(
+    () => provider.log({ level: { value: 30 } }),
+    { code: 'ERR_INVALID_RETURN_VALUE' },
+  );
+}
+
+{
+  const script = `
+    const assert = require('node:assert');
+    const { ConsoleProvider, create } = require('node:logger');
+    const provider = new ConsoleProvider();
+    const logger = create(provider);
+    let synchronous = true;
+    let flushed = false;
+
+    process.on('beforeExit', () => assert.strictEqual(flushed, true));
+
+    logger.info('asynchronous flush');
+    assert.throws(
+      () => provider.flushSync(),
+      { code: 'ERR_INVALID_STATE' },
+    );
+    provider.flush((error) => {
+      flushed = true;
+      assert.ifError(error);
+      assert.strictEqual(synchronous, false);
+      assert.strictEqual(provider.stream.writing, false);
+    });
+    synchronous = false;
+  `;
+  const result = spawnSync(process.execPath, [
+    '--experimental-logger',
+    '--no-warnings',
+    '-e',
+    script,
+  ], { encoding: 'utf8' });
+
+  assert.strictEqual(result.status, 0);
+  assert.strictEqual(result.stderr, '');
+  assert.strictEqual(JSON.parse(result.stdout).message, 'asynchronous flush');
+}
diff --git a/test/parallel/test-logger-diagnostics-provider.js b/test/parallel/test-logger-diagnostics-provider.js
new file mode 100644
index 000000000000..568b46b0ab33
--- /dev/null
+++ b/test/parallel/test-logger-diagnostics-provider.js
@@ -0,0 +1,83 @@
+// Flags: --experimental-logger
+
+'use strict';
+
+const common = require('../common');
+const assert = require('node:assert');
+const { channel } = require('node:diagnostics_channel');
+const { DiagnosticsProvider, create, levels } = require('node:logger');
+
+common.expectWarning(
+  'ExperimentalWarning',
+  'Logger is an experimental feature and might change at any time',
+);
+
+{
+  const allChannel = channel('test:logger:diagnostics:all');
+  const errorChannel = channel('test:logger:diagnostics:error');
+  const allEvents = [];
+  const errorEvents = [];
+  const onAll = common.mustCall((event) => allEvents.push(event), 2);
+  const onError = common.mustCall((event) => errorEvents.push(event));
+  const provider = new DiagnosticsProvider({
+    'test:logger:diagnostics:all':
+      (level) => level.value >= levels.info.value,
+    'test:logger:diagnostics:error':
+      (level) => level.name === 'error',
+  });
+  const logger = create(provider);
+
+  assert.strictEqual(logger.isEnabled('info'), false);
+  allChannel.subscribe(onAll);
+  errorChannel.subscribe(onError);
+  try {
+    logger.debug('filtered');
+    logger.info('info message');
+    logger.error('error message');
+  } finally {
+    allChannel.unsubscribe(onAll);
+    errorChannel.unsubscribe(onError);
+  }
+
+  assert.strictEqual(allEvents[0].level, levels.info);
+  assert.strictEqual(allEvents[1].level, levels.error);
+  assert.strictEqual(errorEvents[0], allEvents[1]);
+}
+
+{
+  const name = 'test:logger:diagnostics:router';
+  const target = channel(name);
+  const events = [];
+  const selectedLevels = [];
+  const onEvent = common.mustCall((event) => events.push(event));
+  const provider = new DiagnosticsProvider((level) => {
+    selectedLevels.push(level.name);
+    return level.name === 'warn' ? name : undefined;
+  });
+  const logger = create(provider);
+
+  target.subscribe(onEvent);
+  try {
+    logger.info('not routed');
+    logger.warn('routed');
+  } finally {
+    target.unsubscribe(onEvent);
+  }
+
+  assert.deepStrictEqual(selectedLevels, ['info', 'warn', 'warn']);
+  assert.strictEqual(events[0].level, levels.warn);
+}
+
+assert.strictEqual(new DiagnosticsProvider({}).isEnabled(levels.fatal), false);
+assert.throws(
+  () => new DiagnosticsProvider(),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+assert.throws(
+  () => new DiagnosticsProvider({ channel: true }),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+assert.throws(
+  () => new DiagnosticsProvider(() => 1).isEnabled(levels.info),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
diff --git a/test/parallel/test-logger-level-dispatch.js b/test/parallel/test-logger-level-dispatch.js
new file mode 100644
index 000000000000..9f3d1a7c91fb
--- /dev/null
+++ b/test/parallel/test-logger-level-dispatch.js
@@ -0,0 +1,327 @@
+// Flags: --experimental-logger --expose-gc
+
+'use strict';
+
+// Tests that level methods for disabled levels are resolved to an empty
+// function ahead of time for providers whose enablement changes are
+// observable, and that they are re-resolved when the enablement changes.
+
+const common = require('../common');
+const assert = require('node:assert');
+const { channel } = require('node:diagnostics_channel');
+const {
+  AggregateProvider,
+  ConsoleProvider,
+  DiagnosticsProvider,
+  EventProvider,
+  Logger,
+  create,
+} = require('node:logger');
+
+common.expectWarning(
+  'ExperimentalWarning',
+  'Logger is an experimental feature and might change at any time',
+);
+
+const levelNames = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+
+function isReal(logger, name) {
+  return logger[name] === Logger.prototype[name];
+}
+
+function assertEnabled(logger, expected) {
+  for (const name of levelNames) {
+    assert.strictEqual(isReal(logger, name), expected.includes(name),
+                       `unexpected method for ${name}`);
+  }
+}
+
+// Disabled levels share a single empty function and are not own properties.
+{
+  const logger = create(new EventProvider({ level: 'warn' }));
+  assertEnabled(logger, ['warn', 'error', 'fatal']);
+  assert.strictEqual(logger.trace, logger.debug);
+  assert.strictEqual(logger.trace, logger.info);
+  assert.strictEqual(logger.trace.length, 0);
+  for (const name of levelNames) {
+    assert.strictEqual(Object.hasOwn(logger, name), false);
+  }
+  assert.ok(logger instanceof Logger);
+  assert.strictEqual(logger.constructor, Logger);
+}
+
+// Level changes on the provider re-resolve existing loggers and children,
+// and an event is delivered only when the method resolves to the real one.
+for (const Provider of [ConsoleProvider, EventProvider]) {
+  const provider = new Provider({ level: 'info' });
+  const logger = create(provider);
+  const child = logger.child({ a: 1 });
+  assertEnabled(logger, ['info', 'warn', 'error', 'fatal']);
+  assertEnabled(child, ['info', 'warn', 'error', 'fatal']);
+
+  provider.level = 'trace';
+  assertEnabled(logger, levelNames);
+  assertEnabled(child, levelNames);
+
+  provider.level = { name: 'custom', value: 55 };
+  assertEnabled(logger, ['fatal']);
+  assertEnabled(child, ['fatal']);
+
+  // Loggers created after the change see the new level.
+  assertEnabled(create(provider), ['fatal']);
+}
+
+{
+  const provider = new EventProvider({ level: 'error' });
+  const logger = create(provider);
+  provider.on('log', common.mustCall(1));
+  logger.warn('discarded');
+  provider.level = 'warn';
+  logger.warn('delivered');
+}
+
+// Loggers with different providers do not share resolutions.
+{
+  const a = create(new EventProvider({ level: 'trace' }));
+  const b = create(new EventProvider({ level: 'fatal' }));
+  assertEnabled(a, levelNames);
+  assertEnabled(b, ['fatal']);
+  assert.notStrictEqual(Object.getPrototypeOf(a), Object.getPrototypeOf(b));
+  // Loggers with the same provider share the dispatch prototype.
+  assert.strictEqual(Object.getPrototypeOf(b),
+                     Object.getPrototypeOf(b.child({})));
+}
+
+// Aggregate providers enable the union of their members, and are
+// re-resolved when a member's level changes.
+{
+  const first = new EventProvider({ level: 'error' });
+  const second = new ConsoleProvider({ level: 'fatal' });
+  const aggregate = new AggregateProvider([first, second, first]);
+  const logger = create(aggregate);
+  const nested = create(new AggregateProvider([aggregate]));
+  assertEnabled(logger, ['error', 'fatal']);
+  assertEnabled(nested, ['error', 'fatal']);
+
+  second.level = 'debug';
+  assertEnabled(logger, ['debug', 'info', 'warn', 'error', 'fatal']);
+  assertEnabled(nested, ['debug', 'info', 'warn', 'error', 'fatal']);
+
+  first.level = 'trace';
+  assertEnabled(logger, levelNames);
+  assertEnabled(nested, levelNames);
+}
+
+// Members without isEnabled() are always enabled.
+{
+  const provider = new EventProvider({ level: 'fatal' });
+  const logger = create(new AggregateProvider([provider, { log() {} }]));
+  assertEnabled(logger, levelNames);
+}
+
+// Collected aggregates do not break member level changes.
+{
+  const provider = new EventProvider({ level: 'fatal' });
+  (() => create(new AggregateProvider([provider])))();
+  globalThis.gc();
+  setImmediate(common.mustCall(() => {
+    provider.level = 'trace';
+    assertEnabled(create(provider), levelNames);
+  }));
+}
+
+// Providers whose enablement cannot be observed keep checking per call.
+{
+  let enabled = false;
+  const provider = {
+    isEnabled: common.mustCall(() => enabled, 2),
+    log: common.mustCall(),
+  };
+  const logger = create(provider);
+  assertEnabled(logger, levelNames);
+  assert.strictEqual(Object.getPrototypeOf(logger), Logger.prototype);
+  logger.info('discarded');
+  enabled = true;
+  logger.info('delivered');
+}
+
+{
+  const target = channel('test:logger:dispatch');
+  const logger = create(new DiagnosticsProvider({
+    'test:logger:dispatch': () => true,
+  }));
+  assertEnabled(logger, levelNames);
+  const onEvent = common.mustCall();
+  target.subscribe(onEvent);
+  logger.info('delivered');
+  target.unsubscribe(onEvent);
+  logger.info('discarded');
+}
+
+// Overriding isEnabled() on a built-in provider opts out of dispatch.
+{
+  class Custom extends EventProvider {
+    isEnabled(level) { return level.value >= 50; }
+  }
+  const logger = create(new Custom({ level: 'trace' }));
+  assertEnabled(logger, levelNames);
+  assert.strictEqual(Object.getPrototypeOf(logger), Logger.prototype);
+
+  const aggregate = create(new AggregateProvider([
+    new EventProvider({ level: 'fatal' }),
+    new Custom(),
+  ]));
+  assertEnabled(aggregate, levelNames);
+}
+
+// Logger subclasses keep their own methods, including overridden levels.
+{
+  class MyLogger extends Logger {
+    debug(message) { return `custom ${message}`; }
+    extra() { return 'extra'; }
+  }
+  const provider = new EventProvider({ level: 'fatal' });
+  const logger = new MyLogger(provider);
+  assert.ok(logger instanceof MyLogger);
+  assert.strictEqual(logger.extra(), 'extra');
+  assert.strictEqual(logger.debug('x'), 'custom x');
+  assert.notStrictEqual(logger.trace, Logger.prototype.trace);
+  assert.strictEqual(logger.trace, create(provider).trace);
+
+  provider.level = 'trace';
+  assert.strictEqual(logger.debug('x'), 'custom x');
+  assert.strictEqual(logger.trace, Logger.prototype.trace);
+
+  // Plain loggers with the same provider are unaffected by the subclass.
+  assertEnabled(create(provider), levelNames);
+}
+
+// create(), child(), and `new Logger()` all end up with the same dispatch
+// prototype for a given provider, however the provider is passed.
+{
+  const provider = new EventProvider({ level: 'warn' });
+  const fromCreate = create(provider);
+  const dispatch = Object.getPrototypeOf(fromCreate);
+  assert.notStrictEqual(dispatch, Logger.prototype);
+  assert.strictEqual(Object.getPrototypeOf(dispatch), Logger.prototype);
+  assert.strictEqual(Object.getPrototypeOf(new Logger(provider)), dispatch);
+  assert.strictEqual(Object.getPrototypeOf(fromCreate.child({ a: 1 })),
+                     dispatch);
+  assert.strictEqual(Object.getPrototypeOf(create(provider, { name: 'x' })),
+                     dispatch);
+  assert.strictEqual(fromCreate.constructor, Logger);
+
+  // The default provider, whether omitted or replaced by options.
+  const defaultDispatch = Object.getPrototypeOf(new Logger());
+  assert.notStrictEqual(defaultDispatch, Logger.prototype);
+  assert.strictEqual(Object.getPrototypeOf(create()), defaultDispatch);
+  assert.strictEqual(Object.getPrototypeOf(create({ name: 'x' })),
+                     defaultDispatch);
+  assert.strictEqual(Object.getPrototypeOf(create(null, { name: 'x' })),
+                     defaultDispatch);
+}
+
+// create() reports invalid arguments exactly like the constructor.
+{
+  for (const args of [
+    [{ log() {}, isEnabled: true }],
+    [{ notAProvider: true }, {}],
+    [new EventProvider(), 'not options'],
+    [new EventProvider(), { name: 1 }],
+  ]) {
+    let expected;
+    try {
+      new Logger(...args);
+    } catch (err) {
+      expected = err;
+    }
+    assert.ok(expected);
+    assert.throws(() => create(...args), {
+      name: expected.name,
+      code: expected.code,
+      message: expected.message,
+    });
+  }
+}
+
+// A dispatch prototype is only used for the provider it belongs to, even if
+// a logger for another provider is allocated with it.
+{
+  const quiet = new EventProvider({ level: 'fatal' });
+  const loud = new EventProvider({ level: 'trace' });
+  const quietDispatch = Object.getPrototypeOf(create(quiet));
+  function Crafted() {}
+  Crafted.prototype = quietDispatch;
+  const logger = Reflect.construct(Logger, [loud], Crafted);
+  assertEnabled(logger, levelNames);
+  assert.strictEqual(Object.getPrototypeOf(logger),
+                     Object.getPrototypeOf(create(loud)));
+
+  // Also when the other provider is not dispatchable.
+  const custom = { isEnabled: () => true, log() {} };
+  const plain = Reflect.construct(Logger, [custom], Crafted);
+  assert.strictEqual(Object.getPrototypeOf(plain), Logger.prototype);
+  assertEnabled(plain, levelNames);
+}
+
+// Children, grandchildren, and children of subclass instances get the
+// provider's plain dispatch prototype, and follow level changes.
+{
+  class MyLogger extends Logger {}
+  const provider = new EventProvider({ level: 'error' });
+  const dispatch = Object.getPrototypeOf(create(provider));
+  const parents = [create(provider), new Logger(provider),
+                   new MyLogger(provider)];
+  for (const parent of parents) {
+    const child = parent.child({ a: 1 });
+    const grandchild = child.child({ b: 2 });
+    assert.strictEqual(Object.getPrototypeOf(child), dispatch);
+    assert.strictEqual(Object.getPrototypeOf(grandchild), dispatch);
+    assert.strictEqual(child instanceof MyLogger, false);
+    assertEnabled(grandchild, ['error', 'fatal']);
+  }
+  provider.level = 'trace';
+  assertEnabled(parents[2].child({}).child({}), levelNames);
+
+  // Not dispatchable: children keep the plain prototype.
+  const custom = create({ isEnabled: () => true, log() {} });
+  assert.strictEqual(Object.getPrototypeOf(custom.child({}).child({})),
+                     Logger.prototype);
+}
+
+// Function bindings are resolved for children, including when inherited
+// from the parent, and a value overriding a parent function is used as is.
+{
+  const events = [];
+  const parent = create({ log(event) { events.push(event); } }, {
+    bindings: { dynamic: () => 'resolved', fixed: 1 },
+  });
+  parent.child({ extra: 2 }).info('inherited');
+  parent.child({ dynamic: 'value' }).info('overridden');
+  parent.child({}).child({ more: () => 3 }).info('grandchild');
+  assert.strictEqual(events[0].bindings.dynamic, 'resolved');
+  assert.strictEqual(events[0].bindings.extra, 2);
+  assert.strictEqual(events[1].bindings.dynamic, 'value');
+  assert.strictEqual(events[2].bindings.dynamic, 'resolved');
+  assert.strictEqual(events[2].bindings.more, 3);
+}
+
+// Children defer freezing their bindings, but providers and users only ever
+// observe them frozen.
+{
+  const provider = {
+    isEnabled: common.mustCall((level, context) => {
+      assert.ok(Object.isFrozen(context.bindings));
+      return true;
+    }, 2),
+    log: common.mustCall((event, context) => {
+      assert.ok(Object.isFrozen(event.bindings));
+      assert.ok(Object.isFrozen(context.bindings));
+    }, 2),
+  };
+  const parent = create(provider, { bindings: { a: 1 } });
+  const child = parent.child({ b: 2 });
+  assert.ok(Object.isFrozen(parent.child({ c: 3 }).bindings));
+  child.child({ d: 4 }).info('grandchild first');
+  child.info('child');
+}
diff --git a/test/parallel/test-logger.js b/test/parallel/test-logger.js
new file mode 100644
index 000000000000..065fd0772e15
--- /dev/null
+++ b/test/parallel/test-logger.js
@@ -0,0 +1,467 @@
+// Flags: --experimental-logger
+
+'use strict';
+
+const common = require('../common');
+const assert = require('node:assert');
+const { AsyncLocalStorage } = require('node:async_hooks');
+const EventEmitter = require('node:events');
+const { isBuiltin } = require('node:module');
+const loggerModule = require('node:logger');
+const {
+  AggregateProvider,
+  ConsoleProvider,
+  EventProvider,
+  Logger,
+  create,
+  getDefaultProvider,
+  levels,
+  setDefaultProvider,
+} = loggerModule;
+
+common.expectWarning(
+  'ExperimentalWarning',
+  'Logger is an experimental feature and might change at any time',
+);
+
+// Bindings, attributes, levels, and contexts do not inherit from
+// Object.prototype. Their prototype is an empty, frozen object whose own
+// prototype is null.
+function assertNullPrototypeEqual(actual, expected) {
+  const proto = Object.getPrototypeOf(actual);
+  assert.strictEqual(Object.getPrototypeOf(proto), null);
+  assert.deepStrictEqual(Reflect.ownKeys(proto), []);
+  assert.strictEqual(Object.isFrozen(proto), true);
+  assert.deepStrictEqual(actual, { __proto__: proto, ...expected });
+}
+
+assert.strictEqual(isBuiltin('node:logger'), true);
+assert.strictEqual(isBuiltin('logger'), false);
+assert.strictEqual(loggerModule, create);
+
+import('node:logger').then(common.mustCall((logger) => {
+  assert.strictEqual(logger.default, create);
+  assert.strictEqual(logger.create, create);
+  assert.strictEqual(logger.getDefaultProvider, getDefaultProvider);
+  assert.strictEqual(logger.setDefaultProvider, setDefaultProvider);
+}));
+
+{
+  const defaultProvider = getDefaultProvider();
+  const first = loggerModule();
+  const second = create();
+
+  assert.strictEqual(Object.hasOwn(create, 'defaultProvider'), false);
+  assert.strictEqual(getDefaultProvider(), defaultProvider);
+  assert.ok(defaultProvider instanceof ConsoleProvider);
+  assert.ok(first instanceof Logger);
+  assert.strictEqual(first.provider, defaultProvider);
+  assert.strictEqual(second.provider, defaultProvider);
+}
+
+{
+  const original = getDefaultProvider();
+  const provider = new EventProvider();
+  const reentrantProvider = new EventProvider();
+  const events = [];
+  const changes = [];
+  const eventName = 'defaultLoggerProviderChanged';
+  const listener = common.mustCall((changedProvider, currentProvider) => {
+    changes.push([changedProvider, currentProvider]);
+    assert.throws(
+      () => setDefaultProvider(reentrantProvider),
+      { code: 'ERR_INVALID_STATE' },
+    );
+  }, 2);
+  provider.on('log', common.mustCall((event) => events.push(event)));
+
+  process.on(eventName, listener);
+  try {
+    setDefaultProvider(provider);
+    assert.deepStrictEqual(changes, [[provider, original]]);
+    setDefaultProvider(provider);
+    assert.deepStrictEqual(changes, [[provider, original]]);
+    assert.throws(
+      () => setDefaultProvider({}),
+      { code: 'ERR_INVALID_ARG_TYPE' },
+    );
+    assert.deepStrictEqual(changes, [[provider, original]]);
+
+    const logger = create({ name: 'custom-default' });
+    assert.strictEqual(getDefaultProvider(), provider);
+    assert.strictEqual(logger.provider, provider);
+    assert.strictEqual(new Logger().provider, provider);
+    logger.info('redirected');
+    assert.strictEqual(events[0].message, 'redirected');
+  } finally {
+    setDefaultProvider(original);
+    process.off(eventName, listener);
+  }
+
+  assert.deepStrictEqual(changes, [
+    [provider, original],
+    [original, provider],
+  ]);
+  assert.strictEqual(getDefaultProvider(), original);
+}
+
+{
+  const original = getDefaultProvider();
+  const provider = new EventProvider();
+  const expected = new Error('default provider rejected');
+  const eventName = 'defaultLoggerProviderChanged';
+  const listener = common.mustCall(() => { throw expected; });
+
+  process.once(eventName, listener);
+  try {
+    assert.throws(
+      () => setDefaultProvider(provider),
+      (error) => error === expected,
+    );
+    assert.strictEqual(getDefaultProvider(), original);
+
+    setDefaultProvider(provider);
+    assert.strictEqual(getDefaultProvider(), provider);
+  } finally {
+    process.off(eventName, listener);
+    if (getDefaultProvider() !== original) {
+      setDefaultProvider(original);
+    }
+  }
+}
+
+{
+  const invalidThis = {
+    code: 'ERR_INVALID_THIS',
+    message: 'Value of "this" must be of type Logger',
+    name: 'TypeError',
+  };
+  const receivers = [null, undefined, { __proto__: Logger.prototype }];
+  const getters = ['bindings', 'name', 'provider'];
+  const methods = [
+    'child',
+    'debug',
+    'error',
+    'fatal',
+    'info',
+    'isEnabled',
+    'log',
+    'trace',
+    'warn',
+  ];
+
+  for (const receiver of receivers) {
+    for (const name of getters) {
+      const getter = Object.getOwnPropertyDescriptor(Logger.prototype, name).get;
+      assert.throws(() => Reflect.apply(getter, receiver, []), invalidThis);
+    }
+    for (const name of methods) {
+      assert.throws(
+        () => Reflect.apply(Logger.prototype[name], receiver, []),
+        invalidThis,
+      );
+    }
+  }
+}
+
+{
+  const events = [];
+  const contexts = [];
+  const provider = {
+    isEnabled(level, context) {
+      contexts.push(context);
+      return level.value >= levels.debug.value;
+    },
+    log: common.mustCall(function log(event) {
+      assert.strictEqual(this, provider);
+      events.push(event);
+    }, 2),
+  };
+  const inputBindings = { service: 'api' };
+  const logger = create(provider, {
+    name: 'root',
+    bindings: inputBindings,
+  });
+
+  inputBindings.service = 'changed';
+
+  assert.strictEqual(logger.provider, provider);
+  assert.strictEqual(logger.name, 'root');
+  assertNullPrototypeEqual(logger.bindings, {
+    service: 'api',
+  });
+  assert.strictEqual(Object.isFrozen(logger.bindings), true);
+  assert.strictEqual(logger.isEnabled('trace'), false);
+  assert.strictEqual(logger.isEnabled('debug'), true);
+
+  logger.trace('filtered');
+
+  const inputAttributes = { requestId: 1 };
+  logger.info('request received', inputAttributes);
+  inputAttributes.requestId = 2;
+
+  assert.strictEqual(events.length, 1);
+  const event = events[0];
+  assert.strictEqual(event.message, 'request received');
+  assert.strictEqual(event.name, 'root');
+  assert.strictEqual(event.level, levels.info);
+  assert.strictEqual(typeof event.timestamp, 'number');
+  assertNullPrototypeEqual(event.bindings, {
+    service: 'api',
+  });
+  assertNullPrototypeEqual(event.attributes, {
+    requestId: 1,
+  });
+  // Per-event objects are not frozen. The bindings are shared by every
+  // event from the logger, so they are.
+  assert.strictEqual(Object.isFrozen(event), false);
+  assert.strictEqual(Object.isFrozen(event.attributes), false);
+  assert.strictEqual(event.bindings, logger.bindings);
+  assert.strictEqual(Object.isFrozen(event.bindings), true);
+  assert.strictEqual(contexts.at(-1).name, 'root');
+
+  const child = logger.child({ service: 'worker', workerId: 2 });
+  assert.strictEqual(child.provider, provider);
+  assert.strictEqual(child.name, 'root');
+  assertNullPrototypeEqual(child.bindings, {
+    service: 'worker',
+    workerId: 2,
+  });
+
+  child.log({ name: 'notice', value: 35 }, 'custom level');
+  assert.strictEqual(events.length, 2);
+  assertNullPrototypeEqual(events[1].level, {
+    name: 'notice',
+    value: 35,
+  });
+}
+
+{
+  const events = [];
+  const provider = {
+    log(event) {
+      events.push(event);
+    },
+  };
+  const logger = new Logger(provider);
+
+  logger.fatal('fatal message');
+  assert.strictEqual(events.length, 1);
+  assert.strictEqual(logger.isEnabled('trace'), true);
+}
+
+{
+  const bindingStorage = new AsyncLocalStorage();
+  const attributeStorage = new AsyncLocalStorage();
+  const request = common.mustCall(() => bindingStorage.getStore(), 3);
+  const operation = common.mustCall(() => attributeStorage.getStore(), 2);
+  const events = [];
+  const logger = create({
+    log(event) {
+      events.push(event);
+    },
+  }, {
+    bindings: { rawStorage: bindingStorage, request },
+  });
+
+  logger.info('outside', { operation, rawStorage: attributeStorage });
+  bindingStorage.run({ requestId: 1 }, () => {
+    attributeStorage.run('create', () => {
+      logger.info('inside', { operation });
+    });
+  });
+  bindingStorage.run({ requestId: 2 }, () => {
+    logger.info('second request');
+  });
+
+  assert.strictEqual(logger.bindings.request, request);
+  assert.strictEqual(events[0].bindings.rawStorage, bindingStorage);
+  assert.strictEqual(events[0].bindings.request, undefined);
+  assert.strictEqual(events[0].attributes.rawStorage, attributeStorage);
+  assert.strictEqual(events[0].attributes.operation, undefined);
+  assert.deepStrictEqual(events[1].bindings.request, { requestId: 1 });
+  assert.strictEqual(events[1].attributes.operation, 'create');
+  assert.deepStrictEqual(events[2].bindings.request, { requestId: 2 });
+}
+
+{
+  const logger = create({ name: 'options-only' });
+  assert.strictEqual(logger.name, 'options-only');
+  assert.ok(logger.provider instanceof ConsoleProvider);
+}
+
+{
+  const provider = new EventProvider({ level: 'debug' });
+  const logger = create(provider, { name: 'events' });
+  const events = [];
+  const warnings = [];
+
+  assert.ok(provider instanceof EventEmitter);
+  assert.strictEqual(provider.level, levels.debug);
+
+  provider.on('log', common.mustCall((event) => {
+    events.push(event);
+  }, 3));
+  provider.on('warn', common.mustCall((event) => {
+    warnings.push(event);
+  }));
+
+  const message = { text: 'debug message' };
+  logger.trace('filtered');
+  logger.debug(message);
+  logger.warn('warn message');
+  logger.log({ name: 'notice', value: levels.warn.value }, 'notice message');
+  logger.error('error message');
+
+  assert.strictEqual(events.length, 3);
+  assert.strictEqual(events[0].level, levels.debug);
+  assert.strictEqual(events[0].message, message);
+  assert.strictEqual(events[1].level.name, 'notice');
+  assert.strictEqual(events[1].level.value, levels.warn.value);
+  assert.strictEqual(events[2].level, levels.error);
+  assert.strictEqual(warnings.length, 1);
+  assert.strictEqual(warnings[0].level, levels.warn);
+
+  provider.level = 'fatal';
+  assert.strictEqual(provider.level, levels.fatal);
+  assert.strictEqual(logger.isEnabled('error'), false);
+
+  const customLevel = { name: 'notice', value: 35 };
+  provider.level = customLevel;
+  customLevel.value = 0;
+  assert.strictEqual(provider.level.name, 'notice');
+  assert.strictEqual(provider.level.value, 35);
+  assert.strictEqual(Object.isFrozen(provider.level), true);
+}
+
+{
+  const calls = [];
+  let deliveredEvent;
+  let loggerContext;
+  const disabled = {
+    isEnabled: common.mustCall(function isEnabled(level, context) {
+      assert.strictEqual(level, levels.info);
+      loggerContext ??= context;
+      assert.strictEqual(context, loggerContext);
+      return false;
+    }, 2),
+    log: common.mustNotCall(),
+  };
+  const first = {
+    isEnabled: common.mustCall(function isEnabled(level, context) {
+      assert.strictEqual(level, levels.info);
+      loggerContext ??= context;
+      assert.strictEqual(context, loggerContext);
+      return true;
+    }, 2),
+    log: common.mustCall(function log(event, context) {
+      assert.strictEqual(this, first);
+      assert.strictEqual(context, loggerContext);
+      deliveredEvent = event;
+      calls.push('first');
+    }),
+  };
+  const second = {
+    log: common.mustCall(function log(event, context) {
+      assert.strictEqual(this, second);
+      assert.strictEqual(context, loggerContext);
+      assert.strictEqual(event, deliveredEvent);
+      calls.push('second');
+    }),
+  };
+  const input = [disabled, first, second];
+  const provider = new AggregateProvider(input);
+  const logger = create(provider, {
+    name: 'aggregate',
+    bindings: { service: 'api' },
+  });
+
+  input.length = 0;
+  assert.strictEqual(Object.isFrozen(provider.providers), true);
+  assert.deepStrictEqual(provider.providers, [disabled, first, second]);
+
+  logger.info('fan out');
+
+  assert.deepStrictEqual(calls, ['first', 'second']);
+  assert.strictEqual(loggerContext.name, 'aggregate');
+  assertNullPrototypeEqual(loggerContext.bindings, {
+    service: 'api',
+  });
+}
+
+{
+  const provider = new AggregateProvider([]);
+  const logger = create(provider);
+
+  assert.strictEqual(logger.isEnabled('fatal'), false);
+  logger.fatal('discarded');
+}
+
+{
+  const expected = new Error('provider failure');
+  const provider = new AggregateProvider([
+    { log() { throw expected; } },
+    { log: common.mustNotCall() },
+  ]);
+  const logger = create(provider);
+
+  assert.throws(() => logger.info('failed'), (error) => error === expected);
+}
+
+{
+  const destination = { log: common.mustCall() };
+  const provider = new AggregateProvider([
+    new AggregateProvider([destination]),
+  ]);
+
+  create(provider).info('nested');
+}
+
+assert.throws(
+  () => create(1),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+assert.throws(
+  () => create({ log: 'not a function' }, {}),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+assert.throws(
+  () => create({ log() {}, isEnabled: true }),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+assert.throws(
+  () => create({ bindings: [] }),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+assert.throws(
+  () => new AggregateProvider(),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+assert.throws(
+  () => new AggregateProvider([1]),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+assert.throws(
+  () => new AggregateProvider([{ log() {}, isEnabled: true }]),
+  { code: 'ERR_INVALID_ARG_TYPE' },
+);
+
+{
+  const logger = create({ log() {} });
+
+  assert.throws(
+    () => logger.info('message', []),
+    { code: 'ERR_INVALID_ARG_TYPE' },
+  );
+  assert.throws(
+    () => logger.log('unknown', 'message'),
+    { code: 'ERR_INVALID_ARG_VALUE' },
+  );
+  assert.throws(
+    () => logger.log({ name: 'custom', value: 1.5 }, 'message'),
+    { code: 'ERR_OUT_OF_RANGE' },
+  );
+}
+
+assert.strictEqual(Object.isFrozen(levels), true);
+assert.strictEqual(Object.isFrozen(levels.info), true);
diff --git a/test/parallel/test-module-builtin-experimental.js b/test/parallel/test-module-builtin-experimental.js
index 2a3d75e23c1b..9c3fa45d6531 100644
--- a/test/parallel/test-module-builtin-experimental.js
+++ b/test/parallel/test-module-builtin-experimental.js
@@ -7,6 +7,7 @@ const experimentalBuiltins = [
   ['bench', '--experimental-bench', true],
   ['bench/reporters', '--experimental-bench', true],
   ['dtls', '--experimental-dtls', common.hasDtls],
+  ['logger', '--experimental-logger', true],
   ['quic', '--experimental-quic', common.hasQuic],
   ['vfs', '--experimental-vfs', true],
 ].filter(([, , available]) => available);