report: add --report-disable-network option

New option `--report-disable-network`, also available as `report.disableNetwork`, enables the user to disable networking interfaces in their diagnostic report. On some systems, this can cause the report to take minutes to generate so this option can be used to optimize that.

fixes: #46060

Author: Ethan-Arrowood

lib/internal/process/report.js

@@ -60,6 +60,13 @@ const report = {
     validateBoolean(b, 'compact');
     nr.setCompact(b);
   },
+  get disableNetwork() {
+    return nr.getDisableNetwork();
+  },
+  set disableNetwork(b) {
+    validateBoolean(b, 'disableNetwork');
+    nr.setDisableNetwork(b);
+  },
   get signal() {
     return nr.getSignal();
   },

src/node_options.cc

@@ -950,6 +950,11 @@ PerProcessOptionsParser::PerProcessOptionsParser(
             "generate diagnostic report on fatal (internal) errors",
             &PerProcessOptions::report_on_fatalerror,
             kAllowedInEnvvar);
+  AddOption("--report-disable-network",
+            "disable network interface diagnostics."
+            " (default: false)",
+            &PerProcessOptions::report_disable_network,
+            kAllowedInEnvvar);
 
 #ifdef NODE_HAVE_I18N_SUPPORT
   AddOption("--icu-data-dir",

src/node_options.h

@@ -306,6 +306,7 @@ class PerProcessOptions : public Options {
   bool report_compact = false;
   std::string report_directory;
   std::string report_filename;
+  bool report_disable_network = false;
 
   // TODO(addaleax): Some of these could probably be per-Environment.
   std::string use_largepages = "off";

src/node_report.cc

@@ -61,8 +61,9 @@ static void WriteNodeReport(Isolate* isolate,
                             const std::string& filename,
                             std::ostream& out,
                             Local<Value> error,
-                            bool compact);
-static void PrintVersionInformation(JSONWriter* writer);
+                            bool compact,
+                            bool disable_network);
+static void PrintVersionInformation(JSONWriter* writer, bool disable_network);
 static void PrintJavaScriptErrorStack(JSONWriter* writer,
                                       Isolate* isolate,
                                       Local<Value> error,
@@ -93,7 +94,8 @@ static void WriteNodeReport(Isolate* isolate,
                             const std::string& filename,
                             std::ostream& out,
                             Local<Value> error,
-                            bool compact) {
+                            bool compact,
+                            bool disable_network) {
   // Obtain the current time and the pid.
   TIME_TYPE tm_struct;
   DiagnosticFilename::LocalTime(&tm_struct);
@@ -174,7 +176,7 @@ static void WriteNodeReport(Isolate* isolate,
   }
 
   // Report Node.js and OS version information
-  PrintVersionInformation(&writer);
+  PrintVersionInformation(&writer, disable_network);
   writer.json_objectend();
 
   if (isolate != nullptr) {
@@ -256,7 +258,7 @@ static void WriteNodeReport(Isolate* isolate,
 }
 
 // Report Node.js version, OS version and machine information.
-static void PrintVersionInformation(JSONWriter* writer) {
+static void PrintVersionInformation(JSONWriter* writer, bool disable_network) {
   std::ostringstream buf;
   // Report Node version
   buf << "v" << NODE_VERSION_STRING;
@@ -300,7 +302,8 @@ static void PrintVersionInformation(JSONWriter* writer) {
   }
 
   PrintCpuInfo(writer);
-  PrintNetworkInterfaceInfo(writer);
+  if (!disable_network)
+    PrintNetworkInterfaceInfo(writer);
 
   char host[UV_MAXHOSTNAMESIZE];
   size_t host_size = sizeof(host);
@@ -917,8 +920,14 @@ std::string TriggerNodeReport(Isolate* isolate,
     compact = per_process::cli_options->report_compact;
   }
 
+  bool disable_network;
+  {
+    Mutex::ScopedLock lock(per_process::cli_options_mutex);
+    disable_network = per_process::cli_options->report_disable_network;
+  }
+
   report::WriteNodeReport(
-      isolate, env, message, trigger, filename, *outstream, error, compact);
+      isolate, env, message, trigger, filename, *outstream, error, compact, disable_network);
 
   // Do not close stdout/stderr, only close files we opened.
   if (outfile.is_open()) {
@@ -969,8 +978,13 @@ void GetNodeReport(Isolate* isolate,
   if (isolate != nullptr) {
     env = Environment::GetCurrent(isolate);
   }
+  bool disable_network;
+  {
+    Mutex::ScopedLock lock(per_process::cli_options_mutex);
+    disable_network = per_process::cli_options->report_disable_network;
+  }
   report::WriteNodeReport(
-      isolate, env, message, trigger, "", out, error, false);
+      isolate, env, message, trigger, "", out, error, false, disable_network);
 }
 
 // External function to trigger a report, writing to a supplied stream.
@@ -983,8 +997,13 @@ void GetNodeReport(Environment* env,
   if (env != nullptr) {
     isolate = env->isolate();
   }
+  bool disable_network;
+  {
+    Mutex::ScopedLock lock(per_process::cli_options_mutex);
+    disable_network = per_process::cli_options->report_disable_network;
+  }
   report::WriteNodeReport(
-      isolate, env, message, trigger, "", out, error, false);
+      isolate, env, message, trigger, "", out, error, false, disable_network);
 }
 
 }  // namespace node

src/node_report_module.cc

@@ -84,6 +84,19 @@ static void SetCompact(const FunctionCallbackInfo<Value>& info) {
   per_process::cli_options->report_compact = compact;
 }
 
+static void GetDisableNetwork(const FunctionCallbackInfo<Value>& info) {
+  Mutex::ScopedLock lock(per_process::cli_options_mutex);
+  info.GetReturnValue().Set(per_process::cli_options->report_disable_network);
+}
+
+static void SetDisableNetwork(const FunctionCallbackInfo<Value>& info) {
+    Mutex::ScopedLock lock(per_process::cli_options_mutex);
+  Environment* env = Environment::GetCurrent(info);
+  Isolate* isolate = env->isolate();
+  bool disable_network = info[0]->ToBoolean(isolate)->Value();
+  per_process::cli_options->report_disable_network = disable_network;
+}
+
 static void GetDirectory(const FunctionCallbackInfo<Value>& info) {
   Mutex::ScopedLock lock(per_process::cli_options_mutex);
   Environment* env = Environment::GetCurrent(info);
@@ -174,6 +187,8 @@ static void Initialize(Local<Object> exports,
   SetMethod(context, exports, "getReport", GetReport);
   SetMethod(context, exports, "getCompact", GetCompact);
   SetMethod(context, exports, "setCompact", SetCompact);
+  SetMethod(context, exports, "getDisableNetwork", GetDisableNetwork);
+  SetMethod(context, exports, "setDisableNetwork", SetDisableNetwork);
   SetMethod(context, exports, "getDirectory", GetDirectory);
   SetMethod(context, exports, "setDirectory", SetDirectory);
   SetMethod(context, exports, "getFilename", GetFilename);
@@ -200,6 +215,8 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(GetReport);
   registry->Register(GetCompact);
   registry->Register(SetCompact);
+  registry->Register(GetDisableNetwork);
+  registry->Register(SetDisableNetwork);
   registry->Register(GetDirectory);
   registry->Register(SetDirectory);
   registry->Register(GetFilename);

test/report/test-report-config.js

@@ -66,6 +66,17 @@ assert.throws(() => {
 }, { code: 'ERR_INVALID_ARG_TYPE' });
 assert.strictEqual(process.report.compact, true);
 
+// Verify that process.report.reportDisableNetwork behaves properly.
+assert.strictEqual(process.report.disableNetwork, true);
+process.report.disableNetwork = false;
+assert.strictEqual(process.report.disableNetwork, false);
+process.report.disableNetwork = true;
+assert.strictEqual(process.report.disableNetwork, true);
+assert.throws(() => {
+  process.report.disableNetwork = {};
+}, { code: 'ERR_INVALID_ARG_TYPE' });
+assert.strictEqual(process.report.disableNetwork, true);
+
 if (!common.isWindows) {
   // Verify that process.report.signal behaves properly.
   assert.strictEqual(process.report.signal, 'SIGUSR2');

test/report/test-report-disable-network.js

@@ -0,0 +1,37 @@
+'use strict';
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const tmpdir = require('../common/tmpdir');
+const { describe, it, before } = require('node:test');
+const fs = require('node:fs');
+const helper = require('../common/report');
+
+function validate(pid) {
+  const reports = helper.findReports(pid, tmpdir.path);
+  assert.equal(reports.length, 1);
+  let report = fs.readFileSync(reports[0], { encoding: 'utf8' });
+  report = JSON.parse(report);
+  assert.equal(report.header.networkInterfaces, undefined);
+  fs.unlinkSync(reports[0]);
+}
+
+describe('report disable network option', () => {
+  before(() => {
+    tmpdir.refresh();
+    process.report.directory = tmpdir.path;
+  });
+
+  it('should be configurable with --report-disable-network', () => {
+    const args = ['--report-disable-network', '-e', 'process.report.writeReport()'];
+    const child = spawnSync(process.execPath, args, { cwd: tmpdir.path });
+    assert.equal(child.status, 0);
+    assert.equal(child.signal, null);
+    validate(child.pid);
+  });
+
+  it('should be configurable with report.disableNetwork', () => {
+    process.report.disableNetwork = true;
+    process.report.writeReport();
+    validate(process.pid);
+  });
+});