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/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/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/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/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-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'));
+  }
 }
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);