: session_(env->inspector_agent()->Connect(

std::make_unique<V8ProfilerConnection::V8ProfilerSessionDelegate>(

this),

false)),

const char* params,

bool is_profile_request) {

std::stringstream ss;

uint64_t id = next_id();

// V8's inspector protocol cannot take an integer beyond the int32_t limit.

// In practice the id we use is up to 3-5 for the profilers we have

// here.

CHECK_LT(id, static_cast<uint64_t>(std::numeric_limits<int32_t>::max()));

ss << R"({ "id": )" << id;

DCHECK(method != nullptr);

ss << R"(, "method": ")" << method << '"';

if (params != nullptr) {

ss << R"(, "params": )" << params;

}

ss << " }";

std::string message = ss.str();

const uint8_t* message_data =

reinterpret_cast<const uint8_t*>(message.c_str());

// Save the id of the profile request to identify its response.

if (is_profile_request) {

profile_ids_.insert(id);

}

Debug(env(),

DebugCategory::INSPECTOR_PROFILER,

"Dispatching message %s\n",

message.c_str());

session_->Dispatch(StringView(message_data, message.length()));

return id;

const char* path,

std::string_view profile) {

uv_buf_t buf =

uv_buf_init(const_cast<char*>(profile.data()), profile.length());

int ret = WriteFileSync(path, buf);

if (ret != 0) {

char err_buf[128];

uv_err_name_r(ret, err_buf, sizeof(err_buf));

fprintf(stderr, "%s: Failed to write file %s\n", err_buf, path);

return;

}

Debug(env, DebugCategory::INSPECTOR_PROFILER, "Written result to %s\n", path);

std::vector<char>* utf8_out,

size_t* utf8_length,

size_t padding) {

size_t source_len = source.length();

if (source.is8Bit()) {

const char* latin1 = reinterpret_cast<const char*>(source.characters8());

*utf8_length = simdutf::utf8_length_from_latin1(latin1, source_len);

utf8_out->resize(*utf8_length + padding);

size_t result_len =

simdutf::convert_latin1_to_utf8(latin1, source_len, utf8_out->data());

return *utf8_length == result_len;

}

const char16_t* utf16 =

reinterpret_cast<const char16_t*>(source.characters16());

*utf8_length = simdutf::utf8_length_from_utf16(utf16, source_len);

utf8_out->resize(*utf8_length + padding);

size_t result_len =

simdutf::convert_utf16_to_utf8(utf16, source_len, utf8_out->data());

return *utf8_length == result_len;

fs::FSReqWrapSync req_wrap_sync;

int ret = fs::MKDirpSync(nullptr, &req_wrap_sync.req, directory, 0777,

nullptr);

if (ret < 0 && ret != UV_EEXIST) {

char err_buf[128];

uv_err_name_r(ret, err_buf, sizeof(err_buf));

fprintf(stderr,

"%s: Failed to create %s profile directory %s\n",

err_buf,

type,

directory.c_str());

return false;

}

return true;

uint64_t timestamp =

static_cast<uint64_t>(GetCurrentTimeInMicroseconds() / 1000);

return SPrintF("coverage-%s-%s-%s.json",

uv_os_getpid(),

timestamp,

env()->thread_id());

simdjson::ondemand::object* result) {

simdjson::ondemand::object profile_object;

if ((*result)["profile"].get_object().get(profile_object)) {

fprintf(

stderr, "'profile' from %s profile result is not an Object\n", type());

return std::nullopt;

}

std::string_view profile_raw;

if (profile_object.raw_json().get(profile_raw)) {

fprintf(stderr,

"Cannot get raw string of the 'profile' field from %s profile\n",

type());

return std::nullopt;

}

return profile_raw;

// Generate the profile output from the subclass.

auto profile_opt = GetProfile(result);

if (!profile_opt.has_value()) {

return;

}

std::string_view profile = profile_opt.value();

// Create the directory if necessary.

std::string directory = GetDirectory();

DCHECK(!directory.empty());

if (!EnsureDirectory(directory, type())) {

return;

}

std::string filename = GetFilename();

DCHECK(!filename.empty());

std::string path = directory + kPathSeparator + filename;

WriteResult(env_, path.c_str(), profile);

Isolate* isolate = env_->isolate();

HandleScope handle_scope(isolate);

// This is only set up during pre-execution (when the environment variables

// becomes available in the JS land). If it's empty, we don't have coverage

// directory path (which is resolved in JS land at the moment) either, so

// the best we could to is to just discard the profile and do nothing.

// This should only happen in half-baked Environments created using the

// embedder API.

if (env_->source_map_cache_getter().IsEmpty()) {

return;

}

Local<Context> context = env_->context();

Context::Scope context_scope(context);

// Generate the profile output from the subclass.

auto profile_opt = GetProfile(result);

if (!profile_opt.has_value()) {

return;

}

std::string_view profile = profile_opt.value();

// append source-map cache information to coverage object:

Local<Value> source_map_cache_v;

{

TryCatchScope try_catch(env());

{

Isolate::AllowJavascriptExecutionScope allow_js_here(isolate);

Local<Function> source_map_cache_getter = env_->source_map_cache_getter();

if (!source_map_cache_getter->Call(

context, Undefined(isolate), 0, nullptr)

.ToLocal(&source_map_cache_v)) {

return;

}

}

if (try_catch.HasCaught() && !try_catch.HasTerminated()) {

PrintCaughtException(isolate, context, try_catch);

}

}

// Create the directory if necessary.

std::string directory = GetDirectory();

DCHECK(!directory.empty());

if (!EnsureDirectory(directory, type())) {

return;

}

std::string filename = GetFilename();

DCHECK(!filename.empty());

std::string path = directory + kPathSeparator + filename;

// Only insert source map cache when there's source map data at all.

if (!source_map_cache_v->IsUndefined()) {

// It would be more performant to just find the last } and insert the source

// map cache in front of it, but source map cache is still experimental

// anyway so just re-parse it with V8 for now.

Local<String> profile_str;

if (!v8::String::NewFromUtf8(isolate,

profile.data(),

v8::NewStringType::kNormal,

profile.length())

.ToLocal(&profile_str)) {

fprintf(stderr, "Failed to re-parse %s profile as UTF8\n", type());

return;

}

Local<Value> profile_value;

if (!v8::JSON::Parse(context, profile_str).ToLocal(&profile_value) ||

!profile_value->IsObject()) {

fprintf(stderr, "Failed to re-parse %s profile from JSON\n", type());

return;

}

if (profile_value.As<Object>()

->Set(context,

FIXED_ONE_BYTE_STRING(isolate, "source-map-cache"),

source_map_cache_v)

.IsNothing()) {

fprintf(stderr,

"Failed to insert source map cache into %s profile\n",

type());

return;

}

Local<String> result_s;

if (!v8::JSON::Stringify(context, profile_value).ToLocal(&result_s)) {

fprintf(stderr, "Failed to stringify %s profile result\n", type());

return;

}

Utf8Value result_utf8(isolate, result_s);

WriteResult(env_, path.c_str(), result_utf8.ToStringView());

} else {

WriteResult(env_, path.c_str(), profile);

}

simdjson::ondemand::object* result) {

std::string_view profile_raw;

if (result->raw_json().get(profile_raw)) {

fprintf(stderr,

"Cannot get raw string of the 'profile' field from %s profile\n",

type());

return std::nullopt;

}

return profile_raw;

DispatchMessage("Profiler.enable");

DispatchMessage("Profiler.startPreciseCoverage",

R"({ "callCount": true, "detailed": true })");

Debug(env_,

DebugCategory::INSPECTOR_PROFILER,

"V8CoverageConnection::End(), ending = %d\n", ending_);

if (ending_) {

return;

}

ending_ = true;

TakeCoverage();

DispatchMessage("Profiler.enable");

std::string params = R"({ "interval": )";

params += std::to_string(env()->cpu_prof_interval());

params += " }";

DispatchMessage("Profiler.setSamplingInterval", params.c_str());

DispatchMessage("Profiler.start");

Debug(env_,

DebugCategory::INSPECTOR_PROFILER,

"V8CpuProfilerConnection::End(), ending = %d\n", ending_);

if (ending_) {

return;

}

ending_ = true;

DispatchMessage("Profiler.stop", nullptr, true);

DispatchMessage("HeapProfiler.enable");

std::string params = R"({ "samplingInterval": )";

params += std::to_string(env()->heap_prof_interval());

params += " }";

DispatchMessage("HeapProfiler.startSampling", params.c_str());

Debug(env_,

DebugCategory::INSPECTOR_PROFILER,

"V8HeapProfilerConnection::End(), ending = %d\n", ending_);

if (ending_) {

return;

}

ending_ = true;

DispatchMessage("HeapProfiler.stopSampling", nullptr, true);

// TODO(joyeechueng): merge these connections and use one session per env.

Debug(env, DebugCategory::INSPECTOR_PROFILER, "EndStartedProfilers\n");

V8ProfilerConnection* connection = env->cpu_profiler_connection();

if (connection != nullptr) {

connection->End();

}

connection = env->heap_profiler_connection();

if (connection != nullptr) {

connection->End();

}

connection = env->coverage_connection();

if (connection != nullptr) {

connection->End();

}

std::string result = pattern;

static const std::unordered_map<std::string, std::function<std::string()>>

kPlaceholderMap = {

{"${pid}", []() { return std::to_string(uv_os_getpid()); }},

// TODO(haramj): Add more placeholders as needed.

};

for (const auto& [placeholder, getter] : kPlaceholderMap) {

size_t pos = 0;

while ((pos = result.find(placeholder, pos)) != std::string::npos) {

const std::string value = getter();

result.replace(pos, placeholder.length(), value);

pos += value.length();

}

}

return result;

AtExit(env, [](void* env) {

EndStartedProfilers(static_cast<Environment*>(env));

}, env);

std::string coverage_str =

env->env_vars()->Get("NODE_V8_COVERAGE").value_or(std::string());

if (!coverage_str.empty() || env->options()->test_runner_coverage) {

CHECK_NULL(env->coverage_connection());

env->set_coverage_connection(std::make_unique<V8CoverageConnection>(env));

env->coverage_connection()->Start();

}

if (env->options()->cpu_prof) {

const std::string& dir = env->options()->cpu_prof_dir;

env->set_cpu_prof_interval(env->options()->cpu_prof_interval);

env->set_cpu_prof_dir(dir.empty() ? Environment::GetCwd(env->exec_path())

: dir);

if (env->options()->cpu_prof_name.empty()) {

DiagnosticFilename filename(env, "CPU", "cpuprofile");

env->set_cpu_prof_name(*filename);

} else {

std::string resolved_name =

ReplacePlaceholders(env->options()->cpu_prof_name);

env->set_cpu_prof_name(resolved_name);

}

CHECK_NULL(env->cpu_profiler_connection());

env->set_cpu_profiler_connection(

std::make_unique<V8CpuProfilerConnection>(env));

env->cpu_profiler_connection()->Start();

}

if (env->options()->heap_prof) {

const std::string& dir = env->options()->heap_prof_dir;

env->set_heap_prof_interval(env->options()->heap_prof_interval);

env->set_heap_prof_dir(dir.empty() ? Environment::GetCwd(env->exec_path())

: dir);

if (env->options()->heap_prof_name.empty()) {

DiagnosticFilename filename(env, "Heap", "heapprofile");

env->set_heap_prof_name(*filename);

} else {

env->set_heap_prof_name(env->options()->heap_prof_name);

}

env->set_heap_profiler_connection(

std::make_unique<profiler::V8HeapProfilerConnection>(env));

env->heap_profiler_connection()->Start();

}

CHECK(args[0]->IsString());

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

node::Utf8Value directory(env->isolate(), args[0].As<String>());

env->set_coverage_directory(*directory);

CHECK(args[0]->IsFunction());

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

env->set_source_map_cache_getter(args[0].As<Function>());

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

V8CoverageConnection* connection = env->coverage_connection();

Debug(

env,

DebugCategory::INSPECTOR_PROFILER,

"TakeCoverage, connection %s nullptr\n",

connection == nullptr ? "==" : "!=");

if (connection != nullptr) {

Debug(env, DebugCategory::INSPECTOR_PROFILER, "taking coverage\n");

connection->TakeCoverage();

}

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

V8CoverageConnection* connection = env->coverage_connection();

Debug(env,

DebugCategory::INSPECTOR_PROFILER,

"StopCoverage, connection %s nullptr\n",

connection == nullptr ? "==" : "!=");

if (connection != nullptr) {

Debug(env, DebugCategory::INSPECTOR_PROFILER, "Stopping coverage\n");

connection->StopCoverage();

}

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

V8CoverageConnection* connection = env->coverage_connection();

Debug(env,

DebugCategory::INSPECTOR_PROFILER,

"EndCoverage, connection %s nullptr\n",

connection == nullptr ? "==" : "!=");

if (connection != nullptr) {

Debug(env, DebugCategory::INSPECTOR_PROFILER, "Ending coverage\n");

connection->End();

}

Local<Value> unused,

Local<Context> context,

void* priv) {

SetMethod(context, target, "setCoverageDirectory", SetCoverageDirectory);

SetMethod(

context, target, "setSourceMapCacheGetter", SetSourceMapCacheGetter);

SetMethod(context, target, "takeCoverage", TakeCoverage);

SetMethod(context, target, "stopCoverage", StopCoverage);

SetMethod(context, target, "endCoverage", EndCoverage);

registry->Register(SetCoverageDirectory);

registry->Register(SetSourceMapCacheGetter);

registry->Register(TakeCoverage);

registry->Register(StopCoverage);

registry->Register(EndCoverage);