diff --git a/doc/api/fs.md b/doc/api/fs.md
index 5955cfe0bf01..fcfd23f5cdb9 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -8536,12 +8536,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..b0c988347766
--- /dev/null
+++ b/doc/api/logger.md
@@ -0,0 +1,594 @@
+# 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 can only be imported using the `node:` scheme.
+
+## 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.
+
+The event, level, bindings, and attributes objects are shallowly frozen. The
+message value is retained as provided and is not cloned or frozen. Nested values
+are not cloned or frozen. Providers must treat the entire event as read-only 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 an immutable level descriptor. The same
+immutable `context` is passed to both methods and contains the logger's `name`
+and `bindings`. 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.
+
+```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
+[`ConsoleProvider`]: #class-consoleprovider
+[`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 c237943b69f0..b202fa21310b 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
@@ -4642,6 +4656,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/lib/internal/bootstrap/realm.js b/lib/internal/bootstrap/realm.js
index 81ac2a0e398e..2ab1714f6eac 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',
diff --git a/lib/internal/streams/fast-utf8-stream.js b/lib/internal/streams/fast-utf8-stream.js
index 8a1b6185e828..426843a62c4d 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;
 
@@ -54,6 +55,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
@@ -67,7 +69,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;
@@ -224,7 +228,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();
     }
   }
@@ -259,7 +267,9 @@ class Utf8Stream extends EventEmitter {
     }
 
     if (this.#opening) {
-      this.once('ready', () => this.reopen(file));
+      this.once('ready', () => {
+        if (!this.#destroyed) this.reopen(file);
+      });
       return;
     }
 
@@ -302,7 +312,7 @@ class Utf8Stream extends EventEmitter {
 
     if (this.#opening) {
       this.once('ready', () => {
-        this.end();
+        if (!this.#destroyed) this.end();
       });
       return;
     }
@@ -320,7 +330,7 @@ class Utf8Stream extends EventEmitter {
     if (this.#len > 0 && this.#fd >= 0) {
       this.#actualWrite();
     } else {
-      this.#actualClose();
+      this.#finishEnding();
     }
   }
 
@@ -328,7 +338,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} */
@@ -422,6 +436,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);
     }
@@ -431,25 +457,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();
     }
   }
 
@@ -498,12 +518,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());
       }
     };
 
@@ -529,16 +550,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;
     }
 
@@ -623,7 +687,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;
     }
@@ -661,7 +729,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 = '';
     }
@@ -697,37 +769,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);
   }
 
@@ -744,7 +837,7 @@ class Utf8Stream extends EventEmitter {
       throw error;
     }
 
-    if (this.#minLength <= 0) {
+    if (this.#minLength <= 0 && !this.#writing && this.#len === 0) {
       cb?.();
       return;
     }
@@ -778,7 +871,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..4a10cd016414
--- /dev/null
+++ b/lib/logger.js
@@ -0,0 +1,663 @@
+'use strict';
+
+const {
+  ArrayPrototypeIncludes,
+  ArrayPrototypePop,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  DateNow,
+  FunctionPrototypeCall,
+  JSONStringify,
+  ObjectAssign,
+  ObjectDefineProperties,
+  ObjectFreeze,
+  ObjectKeys,
+  ReflectOwnKeys,
+  SafeWeakMap,
+  String,
+} = 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');
+
+const kDestinations = ['stdout', 'stderr'];
+const kEmptyAttributes = ObjectFreeze({ __proto__: null });
+const kEmptyBindings = ObjectFreeze({ __proto__: null });
+
+function createLevel(name, value) {
+  return ObjectFreeze({ __proto__: null, name, value });
+}
+
+const levels = ObjectFreeze({
+  __proto__: null,
+  trace: createLevel('trace', 10),
+  debug: createLevel('debug', 20),
+  info: createLevel('info', 30),
+  warn: createLevel('warn', 40),
+  error: createLevel('error', 50),
+  fatal: createLevel('fatal', 60),
+});
+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 createLevel(levelName, value);
+}
+
+function copyObject(value, resolveFunctions = false) {
+  const copy = ObjectAssign({ __proto__: null }, value);
+  if (resolveFunctions) {
+    const keys = ReflectOwnKeys(copy);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const entry = copy[key];
+      if (typeof entry === 'function') {
+        copy[key] = FunctionPrototypeCall(entry);
+      }
+    }
+  }
+  return ObjectFreeze(copy);
+}
+
+function hasFunction(value) {
+  const keys = ReflectOwnKeys(value);
+  for (let i = 0; i < keys.length; i++) {
+    if (typeof value[keys[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;
+}
+
+function serializeError(error) {
+  const serialized = ObjectAssign({ __proto__: null }, error, {
+    __proto__: null,
+    message: error.message,
+    name: error.name,
+    stack: error.stack,
+  });
+  if (error.code !== undefined) serialized.code = error.code;
+  if (error.cause !== undefined) serialized.cause = error.cause;
+  if (error.errors !== undefined) serialized.errors = error.errors;
+  return serialized;
+}
+
+function defaultSerializer(event) {
+  const ancestors = [];
+  const replacements = new SafeWeakMap();
+
+  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.set(serialized, value);
+      return serialized;
+    }
+    return value;
+  });
+}
+
+/**
+ * A provider that fans log events out to multiple providers.
+ */
+class AggregateProvider {
+  #providers;
+
+  constructor(providers) {
+    validateArray(providers, 'providers');
+    const copy = ArrayPrototypeSlice(providers);
+    for (let i = 0; i < copy.length; i++) {
+      validateProvider(copy[i], `providers[${i}]`);
+    }
+    this.#providers = ObjectFreeze(copy);
+  }
+
+  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;
+  #serializer;
+  #stream;
+
+  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 = normalizeLevel(level, 'options.level');
+    this.#pid = pid;
+    this.#serializer = serializer;
+    this.#stream = new Utf8Stream({
+      __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 = normalizeLevel(level);
+  }
+
+  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) {
+    if (this.isEnabled(event.level)) {
+      let record = event;
+      if (this.#flatten || this.#pid) {
+        record = this.#flatten ? ObjectAssign(
+          { __proto__: null },
+          event.bindings,
+          event.attributes,
+        ) : ObjectAssign({ __proto__: null }, event);
+        if (this.#flatten) {
+          record.level = event.level.value;
+          record.levelName = event.level.name;
+          record.message = event.message;
+          record.name = event.name;
+          record.timestamp = event.timestamp;
+        }
+        if (this.#pid) record.pid = process.pid;
+        ObjectFreeze(record);
+      }
+      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}]`);
+      ArrayPrototypePush(routes, ObjectFreeze({
+        __proto__: null,
+        channel: diagnosticsChannel(name),
+        selector,
+      }));
+    }
+    this.#routes = ObjectFreeze(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;
+
+  constructor(options = kEmptyObject) {
+    validateObject(options, 'options');
+    const { level = 'trace' } = options;
+    const normalizedLevel = normalizeLevel(level, 'options.level');
+
+    super();
+    this.#level = normalizedLevel;
+  }
+
+  get level() {
+    return this.#level;
+  }
+
+  set level(level) {
+    this.#level = normalizeLevel(level);
+  }
+
+  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;
+
+class Logger {
+  #bindings;
+  #context;
+  #hasFunction;
+  #name;
+  #provider;
+
+  static {
+    isLogger = (obj) => {
+      return obj !== null && typeof obj === 'object' && #provider in obj;
+    };
+  }
+
+  constructor(providerOrOptions, options) {
+    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');
+    }
+
+    this.#provider = provider;
+    this.#name = name;
+    this.#bindings = copyObject(bindings);
+    this.#hasFunction = hasFunction(this.#bindings);
+    this.#context = ObjectFreeze({
+      __proto__: null,
+      bindings: this.#bindings,
+      name: this.#name,
+    });
+  }
+
+  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');
+    }
+    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');
+    }
+
+    return new Logger(this.#provider, {
+      __proto__: null,
+      bindings: ObjectAssign({ __proto__: null }, this.#bindings, bindings),
+      name,
+    });
+  }
+
+  #isEnabled(level) {
+    return isProviderEnabled(this.#provider, level, this.#context);
+  }
+
+  #log(level, message, attributes) {
+    if (!this.#isEnabled(level)) {
+      return;
+    }
+
+    validateObject(attributes, 'attributes');
+
+    const event = ObjectFreeze({
+      __proto__: null,
+      attributes: attributes === kEmptyAttributes ?
+        attributes : copyObject(attributes, true),
+      bindings: this.#hasFunction ?
+        copyObject(this.#bindings, true) : this.#bindings,
+      level,
+      message,
+      name: this.#name,
+      timestamp: DateNow(),
+    });
+
+    FunctionPrototypeCall(
+      this.#provider.log,
+      this.#provider,
+      event,
+      this.#context,
+    );
+  }
+}
+
+function create(provider, options) {
+  return new Logger(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) {
+  return {
+    __proto__: null,
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true,
+  };
+}
+
+ObjectDefineProperties(create, {
+  __proto__: null,
+  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),
+});
+
+module.exports = create;
diff --git a/test/module-hooks/test-module-hooks-builtin-require.js b/test/module-hooks/test-module-hooks-builtin-require.js
index e1e137ce1169..3c973e53d641 100644
--- a/test/module-hooks/test-module-hooks-builtin-require.js
+++ b/test/module-hooks/test-module-hooks-builtin-require.js
@@ -13,6 +13,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 946fc1e48766..00c5678afbe1 100644
--- a/test/module-hooks/test-module-hooks-load-builtin-require.js
+++ b/test/module-hooks/test-module-hooks-load-builtin-require.js
@@ -37,6 +37,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.js b/test/parallel/test-logger-console-provider.js
new file mode 100644
index 000000000000..e5da9b9f2ec7
--- /dev/null
+++ b/test/parallel/test-logger-console-provider.js
@@ -0,0 +1,252 @@
+'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, ['--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);
+}
+
+{
+  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, [
+    '--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, [
+    '--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, [
+    '--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..4cf66d6b08f2
--- /dev/null
+++ b/test/parallel/test-logger-diagnostics-provider.js
@@ -0,0 +1,81 @@
+'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.js b/test/parallel/test-logger.js
new file mode 100644
index 000000000000..77794939a75d
--- /dev/null
+++ b/test/parallel/test-logger.js
@@ -0,0 +1,456 @@
+'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',
+);
+
+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');
+  assert.deepStrictEqual(logger.bindings, {
+    __proto__: null,
+    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');
+  assert.deepStrictEqual(event.bindings, {
+    __proto__: null,
+    service: 'api',
+  });
+  assert.deepStrictEqual(event.attributes, {
+    __proto__: null,
+    requestId: 1,
+  });
+  assert.strictEqual(Object.isFrozen(event), true);
+  assert.strictEqual(Object.isFrozen(event.attributes), 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');
+  assert.deepStrictEqual(child.bindings, {
+    __proto__: null,
+    service: 'worker',
+    workerId: 2,
+  });
+
+  child.log({ name: 'notice', value: 35 }, 'custom level');
+  assert.strictEqual(events.length, 2);
+  assert.deepStrictEqual(events[1].level, {
+    __proto__: null,
+    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');
+  assert.deepStrictEqual(loggerContext.bindings, {
+    __proto__: null,
+    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);