public TracingController::TraceStateObserver {

public:

void OnTraceEnabled() override {

char name_buffer[512];

if (uv_get_process_title(name_buffer, sizeof(name_buffer)) == 0) {

// Only emit the metadata event if the title can be retrieved

// successfully. Ignore it otherwise.

TRACE_EVENT_METADATA1("__metadata", "process_name",

"name", TRACE_STR_COPY(name_buffer));

}

TRACE_EVENT_METADATA1("__metadata", "version",

"node", NODE_VERSION_STRING);

TRACE_EVENT_METADATA1("__metadata", "thread_name",

"name", "JavaScriptMainThread");

auto trace_process = tracing::TracedValue::Create();

trace_process->BeginDictionary("versions");

const char http_parser_version[] =

NODE_STRINGIFY(HTTP_PARSER_VERSION_MAJOR)

"."

NODE_STRINGIFY(HTTP_PARSER_VERSION_MINOR)

"."

NODE_STRINGIFY(HTTP_PARSER_VERSION_PATCH);

const char node_napi_version[] = NODE_STRINGIFY(NAPI_VERSION);

const char node_modules_version[] = NODE_STRINGIFY(NODE_MODULE_VERSION);

trace_process->SetString("http_parser", http_parser_version);

trace_process->SetString("node", NODE_VERSION_STRING);

trace_process->SetString("v8", V8::GetVersion());

trace_process->SetString("uv", uv_version_string());

trace_process->SetString("zlib", ZLIB_VERSION);

trace_process->SetString("ares", ARES_VERSION_STR);

trace_process->SetString("modules", node_modules_version);

trace_process->SetString("nghttp2", NGHTTP2_VERSION);

trace_process->SetString("napi", node_napi_version);

#if HAVE_OPENSSL

// Stupid code to slice out the version string.

{ // NOLINT(whitespace/braces)

size_t i, j, k;

int c;

for (i = j = 0, k = sizeof(OPENSSL_VERSION_TEXT) - 1; i < k; ++i) {

c = OPENSSL_VERSION_TEXT[i];

if ('0' <= c && c <= '9') {

for (j = i + 1; j < k; ++j) {

c = OPENSSL_VERSION_TEXT[j];

if (c == ' ')

break;

}

break;

}

}

trace_process->SetString("openssl",

std::string(&OPENSSL_VERSION_TEXT[i], j - i));

}

#endif

trace_process->EndDictionary();

trace_process->SetString("arch", NODE_ARCH);

trace_process->SetString("platform", NODE_PLATFORM);

trace_process->BeginDictionary("release");

trace_process->SetString("name", NODE_RELEASE);

#if NODE_VERSION_IS_LTS

trace_process->SetString("lts", NODE_VERSION_LTS_CODENAME);

#endif

trace_process->EndDictionary();

TRACE_EVENT_METADATA1("__metadata", "node",

"process", std::move(trace_process));

// This only runs the first time tracing is enabled

controller_->RemoveTraceStateObserver(this);

delete this;

}

void OnTraceDisabled() override {

// Do nothing here. This should never be called because the

// observer removes itself when OnTraceEnabled() is called.

UNREACHABLE();

}

explicit NodeTraceStateObserver(TracingController* controller) :

controller_(controller) {}

~NodeTraceStateObserver() override {}

private:

TracingController* controller_;

tracing_agent_.reset(new tracing::Agent());

auto controller = tracing_agent_->GetTracingController();

controller->AddTraceStateObserver(new NodeTraceStateObserver(controller));

tracing::TraceEventHelper::SetTracingController(controller);

StartTracingAgent();

platform_ = new NodePlatform(thread_pool_size, controller);

V8::InitializePlatform(platform_);

tracing_agent_.reset(nullptr);

platform_->Shutdown();

delete platform_;

platform_ = nullptr;

std::shared_ptr<DebugOptions> options) {

// Inspector agent can't fail to start, but if it was configured to listen

// right away on the websocket port and fails to bind/etc, this will return

// false.

return env->inspector_agent()->Start(

script_path == nullptr ? "" : script_path, options, true);

if (per_process_opts->trace_event_categories.empty()) {

tracing_file_writer_ = tracing_agent_->DefaultHandle();

} else {

tracing_file_writer_ = tracing_agent_->AddClient(

ParseCommaSeparatedSet(per_process_opts->trace_event_categories),

std::unique_ptr<tracing::AsyncTraceWriter>(

new tracing::NodeTraceWriter(

per_process_opts->trace_event_file_pattern)),

tracing::Agent::kUseDefaultCategories);

}

const DebugOptions& options) {

env->ThrowError("Node compiled with NODE_USE_V8_PLATFORM=0");

return true;

if (!trace_enabled_categories.empty()) {

fprintf(stderr, "Node compiled with NODE_USE_V8_PLATFORM=0, "

"so event tracing is not available.\n");

}

va_list ap;

va_start(ap, format);

#ifdef _WIN32

HANDLE stderr_handle = GetStdHandle(STD_ERROR_HANDLE);

// Check if stderr is something other than a tty/console

if (stderr_handle == INVALID_HANDLE_VALUE ||

stderr_handle == nullptr ||

uv_guess_handle(_fileno(stderr)) != UV_TTY) {

vfprintf(stderr, format, ap);

va_end(ap);

return;

}

// Fill in any placeholders

int n = _vscprintf(format, ap);

std::vector<char> out(n + 1);

vsprintf(out.data(), format, ap);

// Get required wide buffer size

n = MultiByteToWideChar(CP_UTF8, 0, out.data(), -1, nullptr, 0);

std::vector<wchar_t> wbuf(n);

MultiByteToWideChar(CP_UTF8, 0, out.data(), -1, wbuf.data(), n);

// Don't include the null character in the output

CHECK_GT(n, 0);

WriteConsoleW(stderr_handle, wbuf.data(), n - 1, nullptr, nullptr);

#else

vfprintf(stderr, format, ap);

#endif

va_end(ap);

#if !defined(__CloudABI__) && !defined(_WIN32)

if (linux_at_secure || getuid() != geteuid() || getgid() != getegid())

goto fail;

#endif

{

Mutex::ScopedLock lock(environ_mutex);

if (const char* value = getenv(key)) {

*text = value;

return true;

}

}

fail:

text->clear();

return false;

HandleScope scope(isolate);

Environment* env = Environment::GetCurrent(isolate);

return env != nullptr &&

env->should_abort_on_uncaught_toggle()[0] &&

!env->inside_should_not_abort_on_uncaught_scope();

Environment* env = Environment::GetCurrent(isolate);

CHECK_NOT_NULL(env);

env->AddPromiseHook(fn, arg);

void (*fun)(void* arg),

void* arg) {

Environment* env = Environment::GetCurrent(isolate);

CHECK_NOT_NULL(env);

env->AddCleanupHook(fun, arg);

void (*fun)(void* arg),

void* arg) {

Environment* env = Environment::GetCurrent(isolate);

CHECK_NOT_NULL(env);

env->RemoveCleanupHook(fun, arg);

Local<Object> recv,

const Local<Function> callback,

int argc,

Local<Value> argv[],

async_context asyncContext) {

CHECK(!recv.IsEmpty());

InternalCallbackScope scope(env, recv, asyncContext);

if (scope.Failed()) {

return MaybeLocal<Value>();

}

Local<Function> domain_cb = env->domain_callback();

MaybeLocal<Value> ret;

if (asyncContext.async_id != 0 || domain_cb.IsEmpty() || recv.IsEmpty()) {

ret = callback->Call(env->context(), recv, argc, argv);

} else {

std::vector<Local<Value>> args(1 + argc);

args[0] = callback;

std::copy(&argv[0], &argv[argc], args.begin() + 1);

ret = domain_cb->Call(env->context(), recv, args.size(), &args[0]);

}

if (ret.IsEmpty()) {

scope.MarkAsFailed();

return MaybeLocal<Value>();

}

scope.Close();

if (scope.Failed()) {

return MaybeLocal<Value>();

}

return ret;

Local<Object> recv,

const char* method,

int argc,

Local<Value> argv[],

async_context asyncContext) {

Local<String> method_string =

String::NewFromUtf8(isolate, method, NewStringType::kNormal)

.ToLocalChecked();

return MakeCallback(isolate, recv, method_string, argc, argv, asyncContext);

Local<Object> recv,

Local<String> symbol,

int argc,

Local<Value> argv[],

async_context asyncContext) {

Local<Value> callback_v = recv->Get(symbol);

if (callback_v.IsEmpty()) return Local<Value>();

if (!callback_v->IsFunction()) return Local<Value>();

Local<Function> callback = callback_v.As<Function>();

return MakeCallback(isolate, recv, callback, argc, argv, asyncContext);

Local<Object> recv,

Local<Function> callback,

int argc,

Local<Value> argv[],

async_context asyncContext) {

// Observe the following two subtleties:

//

// 1. The environment is retrieved from the callback function's context.

// 2. The context to enter is retrieved from the environment.

//

// Because of the AssignToContext() call in src/node_contextify.cc,

// the two contexts need not be the same.

Environment* env = Environment::GetCurrent(callback->CreationContext());

CHECK_NOT_NULL(env);

Context::Scope context_scope(env->context());

MaybeLocal<Value> ret = InternalMakeCallback(env, recv, callback,

argc, argv, asyncContext);

if (ret.IsEmpty() && env->makecallback_depth() == 0) {

// This is only for legacy compatiblity and we may want to look into

// removing/adjusting it.

return Undefined(env->isolate());

}

return ret;

Local<Object> recv,

const char* method,

int argc,

Local<Value>* argv) {

EscapableHandleScope handle_scope(isolate);

return handle_scope.Escape(

MakeCallback(isolate, recv, method, argc, argv, {0, 0})

.FromMaybe(Local<Value>()));

Local<Object> recv,

Local<String> symbol,

int argc,

Local<Value>* argv) {

EscapableHandleScope handle_scope(isolate);

return handle_scope.Escape(

MakeCallback(isolate, recv, symbol, argc, argv, {0, 0})

.FromMaybe(Local<Value>()));

Local<Object> recv,

Local<Function> callback,

int argc,

Local<Value>* argv) {

EscapableHandleScope handle_scope(isolate);

return handle_scope.Escape(

MakeCallback(isolate, recv, callback, argc, argv, {0, 0})

.FromMaybe(Local<Value>()));

if (!er.IsEmpty() && er->IsObject()) {

Local<Object> err_obj = er.As<Object>();

auto maybe_value =

err_obj->GetPrivate(env->context(), env->decorated_private_symbol());

Local<Value> decorated;

return maybe_value.ToLocal(&decorated) && decorated->IsTrue();

}

return false;

Local<Value> er,

Local<Message> message,

enum ErrorHandlingMode mode) {

if (message.IsEmpty())

return;

HandleScope scope(env->isolate());

Local<Object> err_obj;

if (!er.IsEmpty() && er->IsObject()) {

err_obj = er.As<Object>();

}

// Print (filename):(line number): (message).

ScriptOrigin origin = message->GetScriptOrigin();

node::Utf8Value filename(env->isolate(), message->GetScriptResourceName());

const char* filename_string = *filename;

int linenum = message->GetLineNumber(env->context()).FromJust();

// Print line of source code.

MaybeLocal<String> source_line_maybe = message->GetSourceLine(env->context());

node::Utf8Value sourceline(env->isolate(),

source_line_maybe.ToLocalChecked());

const char* sourceline_string = *sourceline;

if (strstr(sourceline_string, "node-do-not-add-exception-line") != nullptr)

return;

// Because of how node modules work, all scripts are wrapped with a

// "function (module, exports, __filename, ...) {"

// to provide script local variables.

//

// When reporting errors on the first line of a script, this wrapper

// function is leaked to the user. There used to be a hack here to

// truncate off the first 62 characters, but it caused numerous other

// problems when vm.runIn*Context() methods were used for non-module

// code.

//

// If we ever decide to re-instate such a hack, the following steps

// must be taken:

//

// 1. Pass a flag around to say "this code was wrapped"

// 2. Update the stack frame output so that it is also correct.

//

// It would probably be simpler to add a line rather than add some

// number of characters to the first line, since V8 truncates the

// sourceline to 78 characters, and we end up not providing very much

// useful debugging info to the user if we remove 62 characters.

int script_start =

(linenum - origin.ResourceLineOffset()->Value()) == 1 ?

origin.ResourceColumnOffset()->Value() : 0;

int start = message->GetStartColumn(env->context()).FromMaybe(0);

int end = message->GetEndColumn(env->context()).FromMaybe(0);

if (start >= script_start) {

CHECK_GE(end, start);

start -= script_start;

end -= script_start;

}

char arrow[1024];

int max_off = sizeof(arrow) - 2;

int off = snprintf(arrow,

sizeof(arrow),

"%s:%i\n%s\n",

filename_string,

linenum,

sourceline_string);

CHECK_GE(off, 0);

if (off > max_off) {

off = max_off;

}

// Print wavy underline (GetUnderline is deprecated).

for (int i = 0; i < start; i++) {

if (sourceline_string[i] == '\0' || off >= max_off) {

break;

}

CHECK_LT(off, max_off);

arrow[off++] = (sourceline_string[i] == '\t') ? '\t' : ' ';

}

for (int i = start; i < end; i++) {

if (sourceline_string[i] == '\0' || off >= max_off) {

break;

}

CHECK_LT(off, max_off);

arrow[off++] = '^';

}

CHECK_LE(off, max_off);

arrow[off] = '\n';

arrow[off + 1] = '\0';

Local<String> arrow_str = String::NewFromUtf8(env->isolate(), arrow,

NewStringType::kNormal).ToLocalChecked();

const bool can_set_arrow = !arrow_str.IsEmpty() && !err_obj.IsEmpty();

// If allocating arrow_str failed, print it out. There's not much else to do.

// If it's not an error, but something needs to be printed out because

// it's a fatal exception, also print it out from here.

// Otherwise, the arrow property will be attached to the object and handled

// by the caller.

if (!can_set_arrow || (mode == FATAL_ERROR && !err_obj->IsNativeError())) {

if (env->printed_error())

return;

Mutex::ScopedLock lock(process_mutex);

env->set_printed_error(true);

uv_tty_reset_mode();

PrintErrorString("\n%s", arrow);

return;

}

CHECK(err_obj->SetPrivate(

env->context(),

env->arrow_message_private_symbol(),

arrow_str).FromMaybe(false));

Local<Value> er,

Local<Message> message) {

CHECK(!er.IsEmpty());

HandleScope scope(env->isolate());

if (message.IsEmpty())

message = Exception::CreateMessage(env->isolate(), er);

AppendExceptionLine(env, er, message, FATAL_ERROR);

Local<Value> trace_value;

Local<Value> arrow;

const bool decorated = IsExceptionDecorated(env, er);

if (er->IsUndefined() || er->IsNull()) {

trace_value = Undefined(env->isolate());

} else {

Local<Object> err_obj = er->ToObject(env->context()).ToLocalChecked();

trace_value = err_obj->Get(env->stack_string());

arrow =

err_obj->GetPrivate(

env->context(),

env->arrow_message_private_symbol()).ToLocalChecked();

}

node::Utf8Value trace(env->isolate(), trace_value);

// range errors have a trace member set to undefined

if (trace.length() > 0 && !trace_value->IsUndefined()) {

if (arrow.IsEmpty() || !arrow->IsString() || decorated) {

PrintErrorString("%s\n", *trace);

} else {

node::Utf8Value arrow_string(env->isolate(), arrow);

PrintErrorString("%s\n%s\n", *arrow_string, *trace);

}

} else {

// this really only happens for RangeErrors, since they're the only

// kind that won't have all this info in the trace, or when non-Error

// objects are thrown manually.

Local<Value> message;

Local<Value> name;

if (er->IsObject()) {

Local<Object> err_obj = er.As<Object>();

message = err_obj->Get(env->message_string());

name = err_obj->Get(FIXED_ONE_BYTE_STRING(env->isolate(), "name"));

}

if (message.IsEmpty() ||

message->IsUndefined() ||

name.IsEmpty() ||

name->IsUndefined()) {

// Not an error object. Just print as-is.

String::Utf8Value message(env->isolate(), er);

PrintErrorString("%s\n", *message ? *message :

"<toString() threw exception>");

} else {

node::Utf8Value name_string(env->isolate(), name);

node::Utf8Value message_string(env->isolate(), message);

if (arrow.IsEmpty() || !arrow->IsString() || decorated) {

PrintErrorString("%s: %s\n", *name_string, *message_string);

} else {

node::Utf8Value arrow_string(env->isolate(), arrow);

PrintErrorString("%s\n%s: %s\n",

*arrow_string,

*name_string,

*message_string);

}

}

}

fflush(stderr);