From d9ff02c0af506e4991315ae07a06eb6a47f2f089 Mon Sep 17 00:00:00 2001
From: Mert Can Altin <mertgold60@gmail.com>
Date: Sat, 4 Oct 2025 02:46:46 +0300
Subject: [PATCH 1/2] lib: create util.log function

---
 benchmark/util/log.js          |  43 ++++++++++++
 doc/api/util.md                |  81 ++++++++++++++++++++++
 lib/internal/util/log.js       | 111 ++++++++++++++++++++++++++++++
 lib/util.js                    |  10 +++
 src/node_util.cc               |  34 +++++++++
 test/parallel/test-util-log.js | 122 +++++++++++++++++++++++++++++++++
 6 files changed, 401 insertions(+)
 create mode 100644 benchmark/util/log.js
 create mode 100644 lib/internal/util/log.js
 create mode 100644 test/parallel/test-util-log.js

diff --git a/benchmark/util/log.js b/benchmark/util/log.js
new file mode 100644
index 00000000000000..ef3d250d4e4b0a
--- /dev/null
+++ b/benchmark/util/log.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common.js');
+const util = require('util');
+
+const bench = common.createBenchmark(main, {
+  method: ['simple_string', 'object_simple', 'object_complex'],
+  n: [1e4],
+});
+
+function main({ n, method }) {
+  const complexObject = {
+    name: 'test',
+    value: 123,
+    nested: {
+      array: [1, 2, 3, 4, 5],
+      boolean: true,
+      null: null,
+    },
+  };
+
+  bench.start();
+
+  switch (method) {
+    case 'simple_string':
+      for (let i = 0; i < n; i++) {
+        util.log('Hello World');
+      }
+      break;
+    case 'object_simple':
+      for (let i = 0; i < n; i++) {
+        util.log('Number:', i, 'Boolean:', true);
+      }
+      break;
+    case 'object_complex':
+      for (let i = 0; i < n; i++) {
+        util.log('Object:', complexObject);
+      }
+      break;
+  }
+
+  bench.end(n);
+}
diff --git a/doc/api/util.md b/doc/api/util.md
index 0bb5c5c91958d5..7affaa74eb29f5 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -1574,6 +1574,87 @@ inspect.defaultOptions.maxArrayLength = null;
 console.log(arr); // logs the full array
 ```
 
+## `util.log([...args])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `...args` {any}
+
+A high-performance logging function optimized for scenarios where output is
+redirected to files or pipes. The `util.log()` method formats its arguments
+using [`util.format()`][] and writes the result to `stdout` with a trailing
+newline.
+
+```mjs
+import { log } from 'node:util';
+
+log('Hello', 'World');
+// Prints: Hello World
+
+log('User %s logged in', 'alice');
+// Prints: User alice logged in
+```
+
+```cjs
+const { log } = require('node:util');
+
+log('Hello', 'World');
+// Prints: Hello World
+```
+
+### Performance characteristics
+
+The behavior differs based on the output destination:
+
+* **TTY (interactive terminal)**: Synchronous writes for immediate visibility
+* **Pipe/File (redirected output)**: Asynchronous buffering for performance
+  * 16KB buffer size
+  * 10ms flush interval
+  * Automatic flush on `process.beforeExit`
+
+This makes `util.log()` ideal for high-frequency logging when output is
+redirected, while maintaining the same behavior as `console.log()` for
+interactive use.
+
+```mjs
+import { log } from 'node:util';
+
+// High-frequency logging example
+// When redirected (node script.js > output.log):
+// - Buffered and batched for better performance
+// When run in terminal:
+// - Immediate output, same as console.log()
+
+for (let i = 0; i < 10000; i++) {
+  log('Processing item', i);
+}
+```
+
+### When to use `util.log()` vs `console.log()`
+
+Use `util.log()` when:
+
+* You have high-frequency logging (e.g., logging every request in a server)
+* Output is redirected to files or pipes
+* You want to reduce CPU usage from logging overhead
+
+Use `console.log()` when:
+
+* You need guaranteed immediate output before `process.exit()`
+* You're debugging and need synchronous behavior
+* You want consistency with browser JavaScript
+
+**Performance impact**: In high-frequency logging scenarios with redirected
+output, `util.log()` can significantly reduce logging overhead compared to
+`console.log()` through asynchronous buffering and batched writes.
+
+**Important**: Messages logged immediately before `process.exit()` may not be
+written when output is buffered. Use `console.log()` for critical final
+messages, or avoid calling `process.exit()` directly (let the process exit
+naturally).
+
 ## `util.isDeepStrictEqual(val1, val2[, options])`
 
 <!-- YAML
diff --git a/lib/internal/util/log.js b/lib/internal/util/log.js
new file mode 100644
index 00000000000000..faa730ec06db6d
--- /dev/null
+++ b/lib/internal/util/log.js
@@ -0,0 +1,111 @@
+'use strict';
+
+const {
+  ArrayPrototypeJoin,
+  ArrayPrototypePush,
+} = primordials;
+
+const { format } = require('internal/util/inspect');
+const { guessHandleType } = internalBinding('util');
+const {
+  clearTimeout,
+  setTimeout,
+} = require('timers');
+
+// Lazy-load binding to avoid circular dependencies
+let binding;
+function getBinding() {
+  binding ||= internalBinding('util');
+  return binding;
+}
+
+// Buffer configuration
+const kBufferSize = 16384; // 16KB buffer
+const kFlushInterval = 10; // Flush every 10ms
+let pendingBuffer = [];
+let pendingBytes = 0;
+let flushTimer = null;
+let isStdoutTTY = null;
+
+// Check if stdout is TTY (only check once)
+function isTTY() {
+  if (isStdoutTTY === null) {
+    // fd 1 is stdout
+    const type = guessHandleType(1);
+    // Type 1 is TTY, see node_util.cc GetUVHandleTypeCode
+    isStdoutTTY = type === 1;
+  }
+  return isStdoutTTY;
+}
+
+// Flush pending buffer to C++
+function flush() {
+  if (flushTimer !== null) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+
+  if (pendingBuffer.length === 0) return;
+
+  const toWrite = pendingBuffer;
+  pendingBuffer = [];
+  pendingBytes = 0;
+
+  // Batch write: combine all strings and write once
+  // This is much faster than individual write calls
+  // Use join for better performance than string concatenation
+  const combined = ArrayPrototypeJoin(toWrite, '\n') + '\n';
+
+  getBinding().logRaw(combined);
+}
+
+// Schedule flush on next tick
+function scheduleFlush() {
+  if (flushTimer !== null) return;
+
+  flushTimer = setTimeout(flush, kFlushInterval);
+}
+
+/**
+ * High-performance logging function optimized for async buffering.
+ * Unlike console.log, this function is designed for minimal overhead
+ * when output is redirected to files or pipes.
+ *
+ * Behavior:
+ * - TTY (terminal): Synchronous writes for immediate output
+ * - Pipe/File: Async buffering for better performance
+ * @param {...any} args - Values to log
+ */
+function log(...args) {
+  if (args.length === 0) {
+    getBinding().log('');
+    return;
+  }
+
+  // Format arguments using util.format for consistency
+  const formatted = format(...args);
+
+  // If stdout is a TTY, write immediately (sync)
+  // Otherwise, buffer for async writes (better performance)
+  if (isTTY()) {
+    getBinding().log(formatted);
+  } else {
+    // Async buffering path
+    ArrayPrototypePush(pendingBuffer, formatted);
+    pendingBytes += formatted.length;
+
+    // Flush if buffer is full
+    if (pendingBytes >= kBufferSize) {
+      flush();
+    } else {
+      scheduleFlush();
+    }
+  }
+}
+
+// Ensure buffer is flushed before exit
+process.on('beforeExit', flush);
+
+module.exports = {
+  log,
+};
diff --git a/lib/util.js b/lib/util.js
index aa54afee9d369f..b06f5a72cf46ed 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -79,6 +79,13 @@ function lazyUtilColors() {
   utilColors ??= require('internal/util/colors');
   return utilColors;
 }
+
+let utilLog;
+function lazyUtilLog() {
+  utilLog ??= require('internal/util/log');
+  return utilLog;
+}
+
 const { getOptionValue } = require('internal/options');
 
 const binding = internalBinding('util');
@@ -469,6 +476,9 @@ module.exports = {
   callbackify,
   debug: debuglog,
   debuglog,
+  get log() {
+    return lazyUtilLog().log;
+  },
   deprecate,
   format,
   styleText,
diff --git a/src/node_util.cc b/src/node_util.cc
index 601180905d87c9..b265de70601a8b 100644
--- a/src/node_util.cc
+++ b/src/node_util.cc
@@ -4,6 +4,8 @@
 #include "node_external_reference.h"
 #include "util-inl.h"
 #include "v8-fast-api-calls.h"
+#include <cmath>
+#include <climits>
 
 namespace node {
 namespace util {
@@ -251,6 +253,34 @@ static void ParseEnv(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+static void log(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+
+  // JavaScript side sends pre-formatted string, just write it
+  CHECK_EQ(args.Length(), 1);
+  CHECK(args[0]->IsString());
+
+  Utf8Value str(isolate, args[0]);
+  std::string_view sv = str.ToStringView();
+
+  fwrite(sv.data(), 1, sv.length(), stdout);
+  fwrite("\n", 1, 1, stdout);
+}
+
+static void logRaw(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+
+  // For batch writes - no newline added
+  CHECK_EQ(args.Length(), 1);
+  CHECK(args[0]->IsString());
+
+  Utf8Value str(isolate, args[0]);
+  std::string_view sv = str.ToStringView();
+
+  // Write raw string without adding newline
+  fwrite(sv.data(), 1, sv.length(), stdout);
+}
+
 static void GetCallSites(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   Isolate* isolate = env->isolate();
@@ -453,6 +483,8 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(GuessHandleType);
   registry->Register(fast_guess_handle_type_);
   registry->Register(ParseEnv);
+  registry->Register(log);
+  registry->Register(logRaw);
   registry->Register(IsInsideNodeModules);
   registry->Register(DefineLazyProperties);
   registry->Register(DefineLazyPropertiesGetter);
@@ -555,6 +587,8 @@ void Initialize(Local<Object> target,
   SetMethodNoSideEffect(context, target, "getCallSites", GetCallSites);
   SetMethod(context, target, "sleep", Sleep);
   SetMethod(context, target, "parseEnv", ParseEnv);
+  SetMethod(context, target, "log", log);
+  SetMethod(context, target, "logRaw", logRaw);
 
   SetMethod(
       context, target, "arrayBufferViewHasBuffer", ArrayBufferViewHasBuffer);
diff --git a/test/parallel/test-util-log.js b/test/parallel/test-util-log.js
new file mode 100644
index 00000000000000..ed5bf4b72f7684
--- /dev/null
+++ b/test/parallel/test-util-log.js
@@ -0,0 +1,122 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const util = require('util');
+const { spawnSync } = require('child_process');
+
+// Test basic functionality
+{
+  const tests = [
+    { args: [], expected: '\n' },
+    { args: [''], expected: '\n' },
+    { args: ['test'], expected: 'test\n' },
+    { args: ['foo', 'bar'], expected: 'foo bar\n' },
+    { args: [null], expected: 'null\n' },
+    { args: [undefined], expected: 'undefined\n' },
+    { args: [true], expected: 'true\n' },
+    { args: [false], expected: 'false\n' },
+    { args: [42], expected: '42\n' },
+    { args: [3.14], expected: '3.14\n' },
+    { args: [{ a: 1 }], expected: '{ a: 1 }\n' },
+    { args: [[1, 2, 3]], expected: '[ 1, 2, 3 ]\n' },
+    { args: ['Hello %s', 'World'], expected: 'Hello World\n' },
+    { args: ['Number: %d', 42], expected: 'Number: 42\n' },
+  ];
+
+  tests.forEach(({ args, expected }) => {
+    const argsString = args.map((a) => {
+      // Handle undefined specially since JSON.stringify(undefined) === undefined
+      if (a === undefined) return 'undefined';
+      return JSON.stringify(a);
+    }).join(', ');
+
+    const result = spawnSync(process.execPath, [
+      '-e',
+      `require('util').log(${argsString})`,
+    ], { encoding: 'utf8' });
+
+    assert.strictEqual(result.stdout, expected,
+                       `util.log(${args.join(', ')}) failed`);
+  });
+}
+
+// Test that util.log uses util.format
+{
+  const result = spawnSync(process.execPath, [
+    '-e',
+    'require("util").log("test %s %d", "string", 123)',
+  ], { encoding: 'utf8' });
+
+  assert.strictEqual(result.stdout, 'test string 123\n');
+}
+
+// Test async buffering behavior (output redirected to pipe)
+{
+  const script = `
+    const util = require('util');
+    for (let i = 0; i < 10; i++) {
+      util.log('Line', i);
+    }
+  `;
+
+  const result = spawnSync(process.execPath, ['-e', script], {
+    encoding: 'utf8',
+  });
+
+  const lines = result.stdout.trim().split('\n');
+  assert.strictEqual(lines.length, 10);
+  assert.strictEqual(lines[0], 'Line 0');
+  assert.strictEqual(lines[9], 'Line 9');
+}
+
+// Test that util.log is a function
+{
+  assert.strictEqual(typeof util.log, 'function');
+}
+
+// Test beforeExit flush (buffered writes should be flushed)
+{
+  const script = `
+    const util = require('util');
+    // These will be buffered when output is redirected
+    util.log('buffered1');
+    util.log('buffered2');
+    util.log('buffered3');
+    // Process will exit naturally, triggering beforeExit flush
+  `;
+
+  const result = spawnSync(process.execPath, ['-e', script], {
+    encoding: 'utf8',
+  });
+
+  const lines = result.stdout.trim().split('\n');
+  assert.strictEqual(lines.length, 3);
+  assert.strictEqual(lines[0], 'buffered1');
+  assert.strictEqual(lines[1], 'buffered2');
+  assert.strictEqual(lines[2], 'buffered3');
+}
+
+// Test edge cases
+{
+  // Symbol
+  const result1 = spawnSync(process.execPath, [
+    '-e',
+    'require("util").log(Symbol("test"))',
+  ], { encoding: 'utf8' });
+  assert.match(result1.stdout, /Symbol\(test\)/);
+
+  // BigInt
+  const result2 = spawnSync(process.execPath, [
+    '-e',
+    'require("util").log(123n)',
+  ], { encoding: 'utf8' });
+  assert.match(result2.stdout, /123n/);
+
+  // Complex object
+  const result3 = spawnSync(process.execPath, [
+    '-e',
+    'require("util").log({ nested: { value: 1 } })',
+  ], { encoding: 'utf8' });
+  assert.match(result3.stdout, /nested/);
+}

From 17755ff44b244d59e5ac1f0f77d9cb25a690cea9 Mon Sep 17 00:00:00 2001
From: Mert Can Altin <mertgold60@gmail.com>
Date: Sat, 4 Oct 2025 02:58:24 +0300
Subject: [PATCH 2/2] lint

---
 src/node_util.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/node_util.cc b/src/node_util.cc
index b265de70601a8b..131f123ad94b6e 100644
--- a/src/node_util.cc
+++ b/src/node_util.cc
@@ -1,11 +1,11 @@
+#include <climits>
+#include <cmath>
 #include "base_object-inl.h"
 #include "node_dotenv.h"
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "util-inl.h"
 #include "v8-fast-api-calls.h"
-#include <cmath>
-#include <climits>
 
 namespace node {
 namespace util {