Fix version reporting in NodeReport section

Report the versions of Node.js and its components based on the runtime
and not compile time constants.

Extend the tests to validate the versions reported in the report.

Fixes: #29

Author: richardlau

src/module.cc

@@ -302,6 +302,7 @@ void Initialize(v8::Local<v8::Object> exports) {
   node_isolate = isolate;
 
   SetLoadTime();
+  SetVersionString(isolate);
 
   const char* verbose_switch = secure_getenv("NODEREPORT_VERBOSE");
   if (verbose_switch != nullptr) {

src/node_report.cc

@@ -1,9 +1,6 @@
 #include "node_report.h"
-#include "node_version.h"
 #include "v8.h"
 #include "time.h"
-#include "zlib.h"
-#include "ares.h"
 
 #include <fcntl.h>
 #include <string.h>
@@ -52,7 +49,7 @@ using v8::String;
 using v8::V8;
 
 // Internal/static function declarations
-static void PrintVersionInformation(FILE* fp);
+static void PrintVersionInformation(FILE* fp, Isolate* isolate);
 static void PrintJavaScriptStack(FILE* fp, Isolate* isolate, DumpEvent event, const char* location);
 static void PrintStackFromStackTrace(FILE* fp, Isolate* isolate, DumpEvent event);
 static void PrintStackFrame(FILE* fp, Isolate* isolate, Local<StackFrame> frame, int index, void* pc);
@@ -70,6 +67,7 @@ const char* v8_states[] = {"JS", "GC", "COMPILER", "OTHER", "EXTERNAL", "IDLE"};
 static bool report_active = false; // recursion protection
 static char report_filename[NR_MAXNAME + 1] = "";
 static char report_directory[NR_MAXPATH + 1] = ""; // defaults to current working directory
+static std::string versionString = "Unable to determine Node.js version\n";
 #ifdef _WIN32
 static SYSTEMTIME loadtime_tm_struct; // module load time
 #else  // UNIX, OSX
@@ -189,6 +187,73 @@ unsigned int ProcessNodeReportVerboseSwitch(const char* args) {
   return 0;  // Default is verbose mode off
 }
 
+void SetVersionString(Isolate* isolate) {
+  Nan::MaybeLocal<String> processProp = Nan::New<String>("process");
+  if (processProp.IsEmpty()) {
+    return;
+  }
+  Nan::MaybeLocal<Value> process = Nan::Get(
+    isolate->GetCurrentContext()->Global(),
+    processProp.ToLocalChecked());
+  if (process.IsEmpty() || process.ToLocalChecked()->IsUndefined()) {
+    return;
+  }
+  Nan::MaybeLocal<String> versionProp = Nan::New<String>("version");
+  if (versionProp.IsEmpty()) {
+    return;
+  }
+  Nan::MaybeLocal<Value> version = Nan::Get(
+    process.ToLocalChecked().As<Object>(),
+    versionProp.ToLocalChecked());
+  if (version.IsEmpty() || version.ToLocalChecked()->IsUndefined()) {
+    return;
+  }
+  Nan::Utf8String nodeVersion(version.ToLocalChecked());
+  versionString.assign("Node.js version: ");
+  versionString.append(*nodeVersion);
+  versionString.append("\n");
+
+  // Get the component versions
+  Nan::MaybeLocal<String> versionsProp = Nan::New<String>("versions");
+  if (versionsProp.IsEmpty()) {
+    return;
+  }
+  Nan::MaybeLocal<Value> versions = Nan::Get(
+    process.ToLocalChecked().As<Object>(),
+    versionsProp.ToLocalChecked());
+  if (versions.IsEmpty() || versions.ToLocalChecked()->IsUndefined()) {
+    return;
+  }
+  Local<Object> versionsObj = versions.ToLocalChecked().As<Object>();
+  Nan::MaybeLocal<v8::Array> keys = Nan::GetOwnPropertyNames(versionsObj);
+  if (keys.IsEmpty() || keys.ToLocalChecked()->IsUndefined()) {
+    return;
+  }
+  Local<v8::Array> components = keys.ToLocalChecked();
+  for (uint32_t i = 0, nComps = (*components)->Length(); i < nComps; i++) {
+    Nan::MaybeLocal<Value> maybeComp = Nan::Get(components.As<Object>(), i);
+    if (maybeComp.IsEmpty()) {
+      continue;
+    }
+    Local<Value> compValue = maybeComp.ToLocalChecked();
+    Nan::MaybeLocal<Value> maybeVers = Nan::Get(versionsObj, compValue);
+    if (maybeVers.IsEmpty()) {
+      continue;
+    }
+    Local<Value> versValue = maybeVers.ToLocalChecked();
+    Nan::Utf8String compName(compValue);
+    Nan::Utf8String compVersion(versValue);
+    // Don't duplicate the Node.js version
+    if (!strcmp("node", *compName)) {
+      continue;
+    }
+    versionString.append(*compName);
+    versionString.append(": ");
+    versionString.append(*compVersion);
+    versionString.append("\n");
+  }  
+}
+
 /*******************************************************************************
  * Function to save the nodereport module load time value
  *******************************************************************************/
@@ -317,7 +382,7 @@ void TriggerNodeReport(Isolate* isolate, DumpEvent event, const char* message, c
   fflush(fp);
 
   // Print Node.js and OS version information
-  PrintVersionInformation(fp);
+  PrintVersionInformation(fp, isolate);
   fflush(fp);
 
 // Print summary JavaScript stack backtrace
@@ -369,12 +434,10 @@ void TriggerNodeReport(Isolate* isolate, DumpEvent event, const char* message, c
  * Function to print Node.js version, OS version and machine information
  *
  ******************************************************************************/
-static void PrintVersionInformation(FILE* fp) {
+static void PrintVersionInformation(FILE* fp, Isolate* isolate) {
 
   // Print Node.js and deps component versions
-  fprintf(fp, "\nNode.js version: %s\n", NODE_VERSION);
-  fprintf(fp, "(v8: %s, libuv: %s, zlib: %s, ares: %s)\n",
-          V8::GetVersion(), uv_version_string(), ZLIB_VERSION, ARES_VERSION_STR);
+  fprintf(fp, "\n%s", versionString.c_str());
 
   // Print operating system and machine information (Windows)
 #ifdef _WIN32

src/node_report.h

@@ -43,6 +43,7 @@ void ProcessNodeReportDirectory(const char* args);
 unsigned int ProcessNodeReportVerboseSwitch(const char* args);
 
 void SetLoadTime();
+void SetVersionString(Isolate* isolate);
 
 // Local implementation of secure_getenv()
 inline const char* secure_getenv(const char* key) {

test/common.js

@@ -9,6 +9,8 @@ const REPORT_SECTIONS = [
   'System Information'
 ];
 
+const reNewline = '(?:\\r*\\n)';
+
 exports.findReports = (pid) => {
   // Default filenames are of the form NodeReport.<date>.<time>.<pid>.<seq>.txt
   const format = '^NodeReport\\.\\d+\\.\\d+\\.' + pid + '\\.\\d+\\.txt$';
@@ -29,16 +31,36 @@ exports.validate = (t, report, pid) => {
   t.test('Validating ' + report, (t) => {
     fs.readFile(report, (err, data) => {
       const reportContents = data.toString();
-      const plan = REPORT_SECTIONS.length + (pid ? 1 : 0);
+      const nodeComponents = Object.keys(process.versions);
+      const plan = REPORT_SECTIONS.length + (pid ? 1 : 0)
+                 + nodeComponents.length;
       t.plan(plan);
-      if (pid) {
-        t.match(reportContents, new RegExp('Process ID: ' + pid),
-                'Checking report contains expected process ID ' + pid);
-      }
       REPORT_SECTIONS.forEach((section) => {
         t.match(reportContents, new RegExp('==== ' + section),
                 'Checking report contains ' + section + ' section');
       });
+      const nodeReportSection = getSection(reportContents, 'NodeReport');
+      if (pid) {
+        t.match(nodeReportSection, new RegExp('Process ID: ' + pid),
+                'NodeReport section contains expected process ID');
+      }
+      t.match(nodeReportSection, 
+              new RegExp('Node.js version: ' + process.version),
+              'NodeReport section contains expected Node.js version');
+      nodeComponents.forEach((c) => {
+        if (c !== 'node') {
+          t.match(nodeReportSection,
+                  new RegExp(c + ': ' + process.versions[c]),
+                  'NodeReport section contains expected ' + c + ' version');
+        }
+      });
     });
   });
 };
+
+const getSection = (report, section) => {
+  const re = new RegExp('==== ' + section + ' =+' + reNewline + '+([\\S\\s]+?)'
+                        + reNewline + '+={80}' + reNewline);
+  const match = re.exec(report);
+  return match ? match[1] : '';
+};