blob: c93e03afe639183f95079759abf025deed26da73 [file] [log] [blame]
#include "env-inl.h"
#include "json_utils.h"
#include "node_report.h"
#include "debug_utils-inl.h"
#include "diagnosticfilename-inl.h"
#include "node_internals.h"
#include "node_metadata.h"
#include "node_mutex.h"
#include "node_worker.h"
#include "util.h"
#ifdef _WIN32
#include <Windows.h>
#else // !_WIN32
#include <sys/resource.h>
#include <cxxabi.h>
#include <dlfcn.h>
#endif
#include <iostream>
#include <cstring>
#include <ctime>
#include <cwctype>
#include <fstream>
constexpr int NODE_REPORT_VERSION = 2;
constexpr int NANOS_PER_SEC = 1000 * 1000 * 1000;
constexpr double SEC_PER_MICROS = 1e-6;
namespace report {
using node::arraysize;
using node::ConditionVariable;
using node::DiagnosticFilename;
using node::Environment;
using node::JSONWriter;
using node::Mutex;
using node::NativeSymbolDebuggingContext;
using node::TIME_TYPE;
using node::worker::Worker;
using v8::Array;
using v8::Context;
using v8::HeapSpaceStatistics;
using v8::HeapStatistics;
using v8::Isolate;
using v8::Local;
using v8::Number;
using v8::Object;
using v8::StackTrace;
using v8::String;
using v8::TryCatch;
using v8::Value;
using v8::V8;
namespace per_process = node::per_process;
// Internal/static function declarations
static void WriteNodeReport(Isolate* isolate,
Environment* env,
const char* message,
const char* trigger,
const std::string& filename,
std::ostream& out,
Local<Object> error,
bool compact);
static void PrintVersionInformation(JSONWriter* writer);
static void PrintJavaScriptErrorStack(JSONWriter* writer,
Isolate* isolate,
Local<Object> error,
const char* trigger);
static void PrintJavaScriptErrorProperties(JSONWriter* writer,
Isolate* isolate,
Local<Object> error);
static void PrintNativeStack(JSONWriter* writer);
static void PrintResourceUsage(JSONWriter* writer);
static void PrintGCStatistics(JSONWriter* writer, Isolate* isolate);
static void PrintSystemInformation(JSONWriter* writer);
static void PrintLoadedLibraries(JSONWriter* writer);
static void PrintComponentVersions(JSONWriter* writer);
static void PrintRelease(JSONWriter* writer);
static void PrintCpuInfo(JSONWriter* writer);
static void PrintNetworkInterfaceInfo(JSONWriter* writer);
// External function to trigger a report, writing to file.
std::string TriggerNodeReport(Isolate* isolate,
Environment* env,
const char* message,
const char* trigger,
const std::string& name,
Local<Object> error) {
std::string filename;
// Determine the required report filename. In order of priority:
// 1) supplied on API 2) configured on startup 3) default generated
if (!name.empty()) {
// Filename was specified as API parameter.
filename = name;
} else {
std::string report_filename;
{
Mutex::ScopedLock lock(per_process::cli_options_mutex);
report_filename = per_process::cli_options->report_filename;
}
if (report_filename.length() > 0) {
// File name was supplied via start-up option.
filename = report_filename;
} else {
filename = *DiagnosticFilename(env != nullptr ? env->thread_id() : 0,
"report", "json");
}
}
// Open the report file stream for writing. Supports stdout/err,
// user-specified or (default) generated name
std::ofstream outfile;
std::ostream* outstream;
if (filename == "stdout") {
outstream = &std::cout;
} else if (filename == "stderr") {
outstream = &std::cerr;
} else {
std::string report_directory;
{
Mutex::ScopedLock lock(per_process::cli_options_mutex);
report_directory = per_process::cli_options->report_directory;
}
// Regular file. Append filename to directory path if one was specified
if (report_directory.length() > 0) {
std::string pathname = report_directory;
pathname += node::kPathSeparator;
pathname += filename;
outfile.open(pathname, std::ios::out | std::ios::binary);
} else {
outfile.open(filename, std::ios::out | std::ios::binary);
}
// Check for errors on the file open
if (!outfile.is_open()) {
std::cerr << "\nFailed to open Node.js report file: " << filename;
if (report_directory.length() > 0)
std::cerr << " directory: " << report_directory;
std::cerr << " (errno: " << errno << ")" << std::endl;
return "";
}
outstream = &outfile;
std::cerr << "\nWriting Node.js report to file: " << filename;
}
bool compact;
{
Mutex::ScopedLock lock(per_process::cli_options_mutex);
compact = per_process::cli_options->report_compact;
}
WriteNodeReport(isolate, env, message, trigger, filename, *outstream,
error, compact);
// Do not close stdout/stderr, only close files we opened.
if (outfile.is_open()) {
outfile.close();
}
// Do not mix JSON and free-form text on stderr.
if (filename != "stderr") {
std::cerr << "\nNode.js report completed" << std::endl;
}
return filename;
}
// External function to trigger a report, writing to a supplied stream.
void GetNodeReport(Isolate* isolate,
Environment* env,
const char* message,
const char* trigger,
Local<Object> error,
std::ostream& out) {
WriteNodeReport(isolate, env, message, trigger, "", out, error, false);
}
// Internal function to coordinate and write the various
// sections of the report to the supplied stream
static void WriteNodeReport(Isolate* isolate,
Environment* env,
const char* message,
const char* trigger,
const std::string& filename,
std::ostream& out,
Local<Object> error,
bool compact) {
// Obtain the current time and the pid.
TIME_TYPE tm_struct;
DiagnosticFilename::LocalTime(&tm_struct);
uv_pid_t pid = uv_os_getpid();
// Save formatting for output stream.
std::ios old_state(nullptr);
old_state.copyfmt(out);
// File stream opened OK, now start printing the report content:
// the title and header information (event, filename, timestamp and pid)
JSONWriter writer(out, compact);
writer.json_start();
writer.json_objectstart("header");
writer.json_keyvalue("reportVersion", NODE_REPORT_VERSION);
writer.json_keyvalue("event", message);
writer.json_keyvalue("trigger", trigger);
if (!filename.empty())
writer.json_keyvalue("filename", filename);
else
writer.json_keyvalue("filename", JSONWriter::Null{});
// Report dump event and module load date/time stamps
char timebuf[64];
#ifdef _WIN32
snprintf(timebuf,
sizeof(timebuf),
"%4d-%02d-%02dT%02d:%02d:%02dZ",
tm_struct.wYear,
tm_struct.wMonth,
tm_struct.wDay,
tm_struct.wHour,
tm_struct.wMinute,
tm_struct.wSecond);
writer.json_keyvalue("dumpEventTime", timebuf);
#else // UNIX, OSX
snprintf(timebuf,
sizeof(timebuf),
"%4d-%02d-%02dT%02d:%02d:%02dZ",
tm_struct.tm_year + 1900,
tm_struct.tm_mon + 1,
tm_struct.tm_mday,
tm_struct.tm_hour,
tm_struct.tm_min,
tm_struct.tm_sec);
writer.json_keyvalue("dumpEventTime", timebuf);
#endif
uv_timeval64_t ts;
if (uv_gettimeofday(&ts) == 0) {
writer.json_keyvalue("dumpEventTimeStamp",
std::to_string(ts.tv_sec * 1000 + ts.tv_usec / 1000));
}
// Report native process ID
writer.json_keyvalue("processId", pid);
if (env != nullptr)
writer.json_keyvalue("threadId", env->thread_id());
else
writer.json_keyvalue("threadId", JSONWriter::Null{});
{
// Report the process cwd.
char buf[PATH_MAX_BYTES];
size_t cwd_size = sizeof(buf);
if (uv_cwd(buf, &cwd_size) == 0)
writer.json_keyvalue("cwd", buf);
}
// Report out the command line.
if (!node::per_process::cli_options->cmdline.empty()) {
writer.json_arraystart("commandLine");
for (const std::string& arg : node::per_process::cli_options->cmdline) {
writer.json_element(arg);
}
writer.json_arrayend();
}
// Report Node.js and OS version information
PrintVersionInformation(&writer);
writer.json_objectend();
writer.json_objectstart("javascriptStack");
// Report summary JavaScript error stack backtrace
PrintJavaScriptErrorStack(&writer, isolate, error, trigger);
// Report summary JavaScript error properties backtrace
PrintJavaScriptErrorProperties(&writer, isolate, error);
writer.json_objectend(); // the end of 'javascriptStack'
// Report native stack backtrace
PrintNativeStack(&writer);
// Report V8 Heap and Garbage Collector information
PrintGCStatistics(&writer, isolate);
// Report OS and current thread resource usage
PrintResourceUsage(&writer);
writer.json_arraystart("libuv");
if (env != nullptr) {
uv_walk(env->event_loop(), WalkHandle, static_cast<void*>(&writer));
writer.json_start();
writer.json_keyvalue("type", "loop");
writer.json_keyvalue("is_active",
static_cast<bool>(uv_loop_alive(env->event_loop())));
writer.json_keyvalue("address",
ValueToHexString(reinterpret_cast<int64_t>(env->event_loop())));
writer.json_end();
}
writer.json_arrayend();
writer.json_arraystart("workers");
if (env != nullptr) {
Mutex workers_mutex;
ConditionVariable notify;
std::vector<std::string> worker_infos;
size_t expected_results = 0;
env->ForEachWorker([&](Worker* w) {
expected_results += w->RequestInterrupt([&](Environment* env) {
std::ostringstream os;
GetNodeReport(env->isolate(),
env,
"Worker thread subreport",
trigger,
Local<Object>(),
os);
Mutex::ScopedLock lock(workers_mutex);
worker_infos.emplace_back(os.str());
notify.Signal(lock);
});
});
Mutex::ScopedLock lock(workers_mutex);
worker_infos.reserve(expected_results);
while (worker_infos.size() < expected_results)
notify.Wait(lock);
for (const std::string& worker_info : worker_infos)
writer.json_element(JSONWriter::ForeignJSON { worker_info });
}
writer.json_arrayend();
// Report operating system information
PrintSystemInformation(&writer);
writer.json_objectend();
// Restore output stream formatting.
out.copyfmt(old_state);
}
// Report Node.js version, OS version and machine information.
static void PrintVersionInformation(JSONWriter* writer) {
std::ostringstream buf;
// Report Node version
buf << "v" << NODE_VERSION_STRING;
writer->json_keyvalue("nodejsVersion", buf.str());
buf.str("");
#ifndef _WIN32
// Report compiler and runtime glibc versions where possible.
const char* (*libc_version)();
*(reinterpret_cast<void**>(&libc_version)) =
dlsym(RTLD_DEFAULT, "gnu_get_libc_version");
if (libc_version != nullptr)
writer->json_keyvalue("glibcVersionRuntime", (*libc_version)());
#endif /* _WIN32 */
#ifdef __GLIBC__
buf << __GLIBC__ << "." << __GLIBC_MINOR__;
writer->json_keyvalue("glibcVersionCompiler", buf.str());
buf.str("");
#endif
// Report Process word size
writer->json_keyvalue("wordSize", sizeof(void*) * 8);
writer->json_keyvalue("arch", node::per_process::metadata.arch);
writer->json_keyvalue("platform", node::per_process::metadata.platform);
// Report deps component versions
PrintComponentVersions(writer);
// Report release metadata.
PrintRelease(writer);
// Report operating system and machine information
uv_utsname_t os_info;
if (uv_os_uname(&os_info) == 0) {
writer->json_keyvalue("osName", os_info.sysname);
writer->json_keyvalue("osRelease", os_info.release);
writer->json_keyvalue("osVersion", os_info.version);
writer->json_keyvalue("osMachine", os_info.machine);
}
PrintCpuInfo(writer);
PrintNetworkInterfaceInfo(writer);
char host[UV_MAXHOSTNAMESIZE];
size_t host_size = sizeof(host);
if (uv_os_gethostname(host, &host_size) == 0)
writer->json_keyvalue("host", host);
}
// Report CPU info
static void PrintCpuInfo(JSONWriter* writer) {
uv_cpu_info_t* cpu_info;
int count;
if (uv_cpu_info(&cpu_info, &count) == 0) {
writer->json_arraystart("cpus");
for (int i = 0; i < count; i++) {
writer->json_start();
writer->json_keyvalue("model", cpu_info[i].model);
writer->json_keyvalue("speed", cpu_info[i].speed);
writer->json_keyvalue("user", cpu_info[i].cpu_times.user);
writer->json_keyvalue("nice", cpu_info[i].cpu_times.nice);
writer->json_keyvalue("sys", cpu_info[i].cpu_times.sys);
writer->json_keyvalue("idle", cpu_info[i].cpu_times.idle);
writer->json_keyvalue("irq", cpu_info[i].cpu_times.irq);
writer->json_end();
}
writer->json_arrayend();
uv_free_cpu_info(cpu_info, count);
}
}
static void PrintNetworkInterfaceInfo(JSONWriter* writer) {
uv_interface_address_t* interfaces;
char ip[INET6_ADDRSTRLEN];
char netmask[INET6_ADDRSTRLEN];
char mac[18];
int count;
if (uv_interface_addresses(&interfaces, &count) == 0) {
writer->json_arraystart("networkInterfaces");
for (int i = 0; i < count; i++) {
writer->json_start();
writer->json_keyvalue("name", interfaces[i].name);
writer->json_keyvalue("internal", !!interfaces[i].is_internal);
snprintf(mac,
sizeof(mac),
"%02x:%02x:%02x:%02x:%02x:%02x",
static_cast<unsigned char>(interfaces[i].phys_addr[0]),
static_cast<unsigned char>(interfaces[i].phys_addr[1]),
static_cast<unsigned char>(interfaces[i].phys_addr[2]),
static_cast<unsigned char>(interfaces[i].phys_addr[3]),
static_cast<unsigned char>(interfaces[i].phys_addr[4]),
static_cast<unsigned char>(interfaces[i].phys_addr[5]));
writer->json_keyvalue("mac", mac);
if (interfaces[i].address.address4.sin_family == AF_INET) {
uv_ip4_name(&interfaces[i].address.address4, ip, sizeof(ip));
uv_ip4_name(&interfaces[i].netmask.netmask4, netmask, sizeof(netmask));
writer->json_keyvalue("address", ip);
writer->json_keyvalue("netmask", netmask);
writer->json_keyvalue("family", "IPv4");
} else if (interfaces[i].address.address4.sin_family == AF_INET6) {
uv_ip6_name(&interfaces[i].address.address6, ip, sizeof(ip));
uv_ip6_name(&interfaces[i].netmask.netmask6, netmask, sizeof(netmask));
writer->json_keyvalue("address", ip);
writer->json_keyvalue("netmask", netmask);
writer->json_keyvalue("family", "IPv6");
writer->json_keyvalue("scopeid",
interfaces[i].address.address6.sin6_scope_id);
} else {
writer->json_keyvalue("family", "unknown");
}
writer->json_end();
}
writer->json_arrayend();
uv_free_interface_addresses(interfaces, count);
}
}
static void PrintJavaScriptErrorProperties(JSONWriter* writer,
Isolate* isolate,
Local<Object> error) {
writer->json_objectstart("errorProperties");
if (!error.IsEmpty()) {
TryCatch try_catch(isolate);
Local<Context> context = error->GetIsolate()->GetCurrentContext();
Local<Array> keys;
if (!error->GetOwnPropertyNames(context).ToLocal(&keys)) {
return writer->json_objectend(); // the end of 'errorProperties'
}
uint32_t keys_length = keys->Length();
for (uint32_t i = 0; i < keys_length; i++) {
Local<Value> key;
if (!keys->Get(context, i).ToLocal(&key) || !key->IsString()) {
continue;
}
Local<Value> value;
Local<String> value_string;
if (!error->Get(context, key).ToLocal(&value) ||
!value->ToString(context).ToLocal(&value_string)) {
continue;
}
String::Utf8Value k(isolate, key);
if (!strcmp(*k, "stack") || !strcmp(*k, "message")) continue;
String::Utf8Value v(isolate, value_string);
writer->json_keyvalue(std::string(*k, k.length()),
std::string(*v, v.length()));
}
}
writer->json_objectend(); // the end of 'errorProperties'
}
// Report the JavaScript stack.
static void PrintJavaScriptErrorStack(JSONWriter* writer,
Isolate* isolate,
Local<Object> error,
const char* trigger) {
Local<Value> stackstr;
std::string ss = "";
TryCatch try_catch(isolate);
if ((!strcmp(trigger, "FatalError")) ||
(!strcmp(trigger, "Signal"))) {
ss = "No stack.\nUnavailable.\n";
} else if (!error.IsEmpty() &&
error
->Get(isolate->GetCurrentContext(),
node::FIXED_ONE_BYTE_STRING(isolate,
"stack"))
.ToLocal(&stackstr)) {
String::Utf8Value sv(isolate, stackstr);
ss = std::string(*sv, sv.length());
}
int line = ss.find('\n');
if (line == -1) {
writer->json_keyvalue("message", ss);
} else {
std::string l = ss.substr(0, line);
writer->json_keyvalue("message", l);
writer->json_arraystart("stack");
ss = ss.substr(line + 1);
line = ss.find('\n');
while (line != -1) {
l = ss.substr(0, line);
l.erase(l.begin(), std::find_if(l.begin(), l.end(), [](int ch) {
return !std::iswspace(ch);
}));
writer->json_element(l);
ss = ss.substr(line + 1);
line = ss.find('\n');
}
writer->json_arrayend();
}
}
// Report a native stack backtrace
static void PrintNativeStack(JSONWriter* writer) {
auto sym_ctx = NativeSymbolDebuggingContext::New();
void* frames[256];
const int size = sym_ctx->GetStackTrace(frames, arraysize(frames));
writer->json_arraystart("nativeStack");
int i;
for (i = 1; i < size; i++) {
void* frame = frames[i];
writer->json_start();
writer->json_keyvalue("pc",
ValueToHexString(reinterpret_cast<uintptr_t>(frame)));
writer->json_keyvalue("symbol", sym_ctx->LookupSymbol(frame).Display());
writer->json_end();
}
writer->json_arrayend();
}
// Report V8 JavaScript heap information.
// This uses the existing V8 HeapStatistics and HeapSpaceStatistics APIs.
// The isolate->GetGCStatistics(&heap_stats) internal V8 API could potentially
// provide some more useful information - the GC history and the handle counts
static void PrintGCStatistics(JSONWriter* writer, Isolate* isolate) {
HeapStatistics v8_heap_stats;
isolate->GetHeapStatistics(&v8_heap_stats);
HeapSpaceStatistics v8_heap_space_stats;
writer->json_objectstart("javascriptHeap");
writer->json_keyvalue("totalMemory", v8_heap_stats.total_heap_size());
writer->json_keyvalue("totalCommittedMemory",
v8_heap_stats.total_physical_size());
writer->json_keyvalue("usedMemory", v8_heap_stats.used_heap_size());
writer->json_keyvalue("availableMemory",
v8_heap_stats.total_available_size());
writer->json_keyvalue("memoryLimit", v8_heap_stats.heap_size_limit());
writer->json_objectstart("heapSpaces");
// Loop through heap spaces
for (size_t i = 0; i < isolate->NumberOfHeapSpaces(); i++) {
isolate->GetHeapSpaceStatistics(&v8_heap_space_stats, i);
writer->json_objectstart(v8_heap_space_stats.space_name());
writer->json_keyvalue("memorySize", v8_heap_space_stats.space_size());
writer->json_keyvalue(
"committedMemory",
v8_heap_space_stats.physical_space_size());
writer->json_keyvalue(
"capacity",
v8_heap_space_stats.space_used_size() +
v8_heap_space_stats.space_available_size());
writer->json_keyvalue("used", v8_heap_space_stats.space_used_size());
writer->json_keyvalue(
"available", v8_heap_space_stats.space_available_size());
writer->json_objectend();
}
writer->json_objectend();
writer->json_objectend();
}
static void PrintResourceUsage(JSONWriter* writer) {
// Get process uptime in seconds
uint64_t uptime =
(uv_hrtime() - node::per_process::node_start_time) / (NANOS_PER_SEC);
if (uptime == 0) uptime = 1; // avoid division by zero.
// Process and current thread usage statistics
uv_rusage_t rusage;
writer->json_objectstart("resourceUsage");
if (uv_getrusage(&rusage) == 0) {
double user_cpu =
rusage.ru_utime.tv_sec + SEC_PER_MICROS * rusage.ru_utime.tv_usec;
double kernel_cpu =
rusage.ru_stime.tv_sec + SEC_PER_MICROS * rusage.ru_stime.tv_usec;
writer->json_keyvalue("userCpuSeconds", user_cpu);
writer->json_keyvalue("kernelCpuSeconds", kernel_cpu);
double cpu_abs = user_cpu + kernel_cpu;
double cpu_percentage = (cpu_abs / uptime) * 100.0;
writer->json_keyvalue("cpuConsumptionPercent", cpu_percentage);
writer->json_keyvalue("maxRss", rusage.ru_maxrss * 1024);
writer->json_objectstart("pageFaults");
writer->json_keyvalue("IORequired", rusage.ru_majflt);
writer->json_keyvalue("IONotRequired", rusage.ru_minflt);
writer->json_objectend();
writer->json_objectstart("fsActivity");
writer->json_keyvalue("reads", rusage.ru_inblock);
writer->json_keyvalue("writes", rusage.ru_oublock);
writer->json_objectend();
}
writer->json_objectend();
#ifdef RUSAGE_THREAD
struct rusage stats;
if (getrusage(RUSAGE_THREAD, &stats) == 0) {
writer->json_objectstart("uvthreadResourceUsage");
double user_cpu =
stats.ru_utime.tv_sec + SEC_PER_MICROS * stats.ru_utime.tv_usec;
double kernel_cpu =
stats.ru_stime.tv_sec + SEC_PER_MICROS * stats.ru_stime.tv_usec;
writer->json_keyvalue("userCpuSeconds", user_cpu);
writer->json_keyvalue("kernelCpuSeconds", kernel_cpu);
double cpu_abs = user_cpu + kernel_cpu;
double cpu_percentage = (cpu_abs / uptime) * 100.0;
writer->json_keyvalue("cpuConsumptionPercent", cpu_percentage);
writer->json_objectstart("fsActivity");
writer->json_keyvalue("reads", stats.ru_inblock);
writer->json_keyvalue("writes", stats.ru_oublock);
writer->json_objectend();
writer->json_objectend();
}
#endif
}
// Report operating system information.
static void PrintSystemInformation(JSONWriter* writer) {
uv_env_item_t* envitems;
int envcount;
int r;
writer->json_objectstart("environmentVariables");
{
Mutex::ScopedLock lock(node::per_process::env_var_mutex);
r = uv_os_environ(&envitems, &envcount);
}
if (r == 0) {
for (int i = 0; i < envcount; i++)
writer->json_keyvalue(envitems[i].name, envitems[i].value);
uv_os_free_environ(envitems, envcount);
}
writer->json_objectend();
#ifndef _WIN32
static struct {
const char* description;
int id;
} rlimit_strings[] = {
{"core_file_size_blocks", RLIMIT_CORE},
{"data_seg_size_kbytes", RLIMIT_DATA},
{"file_size_blocks", RLIMIT_FSIZE},
#if !(defined(_AIX) || defined(__sun))
{"max_locked_memory_bytes", RLIMIT_MEMLOCK},
#endif
#ifndef __sun
{"max_memory_size_kbytes", RLIMIT_RSS},
#endif
{"open_files", RLIMIT_NOFILE},
{"stack_size_bytes", RLIMIT_STACK},
{"cpu_time_seconds", RLIMIT_CPU},
#ifndef __sun
{"max_user_processes", RLIMIT_NPROC},
#endif
#ifndef __OpenBSD__
{"virtual_memory_kbytes", RLIMIT_AS}
#endif
};
writer->json_objectstart("userLimits");
struct rlimit limit;
std::string soft, hard;
for (size_t i = 0; i < arraysize(rlimit_strings); i++) {
if (getrlimit(rlimit_strings[i].id, &limit) == 0) {
writer->json_objectstart(rlimit_strings[i].description);
if (limit.rlim_cur == RLIM_INFINITY)
writer->json_keyvalue("soft", "unlimited");
else
writer->json_keyvalue("soft", limit.rlim_cur);
if (limit.rlim_max == RLIM_INFINITY)
writer->json_keyvalue("hard", "unlimited");
else
writer->json_keyvalue("hard", limit.rlim_max);
writer->json_objectend();
}
}
writer->json_objectend();
#endif // _WIN32
PrintLoadedLibraries(writer);
}
// Report a list of loaded native libraries.
static void PrintLoadedLibraries(JSONWriter* writer) {
writer->json_arraystart("sharedObjects");
std::vector<std::string> modules =
NativeSymbolDebuggingContext::GetLoadedLibraries();
for (auto const& module_name : modules) writer->json_element(module_name);
writer->json_arrayend();
}
// Obtain and report the node and subcomponent version strings.
static void PrintComponentVersions(JSONWriter* writer) {
std::stringstream buf;
writer->json_objectstart("componentVersions");
#define V(key) \
writer->json_keyvalue(#key, node::per_process::metadata.versions.key);
NODE_VERSIONS_KEYS(V)
#undef V
writer->json_objectend();
}
// Report runtime release information.
static void PrintRelease(JSONWriter* writer) {
writer->json_objectstart("release");
writer->json_keyvalue("name", node::per_process::metadata.release.name);
#if NODE_VERSION_IS_LTS
writer->json_keyvalue("lts", node::per_process::metadata.release.lts);
#endif
#ifdef NODE_HAS_RELEASE_URLS
writer->json_keyvalue("headersUrl",
node::per_process::metadata.release.headers_url);
writer->json_keyvalue("sourceUrl",
node::per_process::metadata.release.source_url);
#ifdef _WIN32
writer->json_keyvalue("libUrl", node::per_process::metadata.release.lib_url);
#endif // _WIN32
#endif // NODE_HAS_RELEASE_URLS
writer->json_objectend();
}
} // namespace report