using v8::Local;

using v8::Locker;

using v8::Maybe;

using v8::Name;

using v8::Null;

using v8::Number;

using v8::Object;

}

}

class WorkerCpuUsageTaker : public AsyncWrap {

public:

WorkerCpuUsageTaker(Environment* env, Local<Object> obj)

: AsyncWrap(env, obj, AsyncWrap::PROVIDER_WORKERCPUUSAGE) {}

SET_NO_MEMORY_INFO()

SET_MEMORY_INFO_NAME(WorkerCpuUsageTaker)

SET_SELF_SIZE(WorkerCpuUsageTaker)

};

void Worker::CpuUsage(const FunctionCallbackInfo<Value>& args) {

Worker* w;

ASSIGN_OR_RETURN_UNWRAP(&w, args.This());

Environment* env = w->env();

AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(w);

Local<Object> wrap;

if (!env->worker_cpu_usage_taker_template()

->NewInstance(env->context())

.ToLocal(&wrap)) {

return;

}

BaseObjectPtr<WorkerCpuUsageTaker> taker =

MakeDetachedBaseObject<WorkerCpuUsageTaker>(env, wrap);

bool scheduled = w->RequestInterrupt([taker = std::move(taker),

env](Environment* worker_env) mutable {

auto cpu_usage_stats = std::make_unique<uv_rusage_t>();

int err = uv_getrusage_thread(cpu_usage_stats.get());

env->SetImmediateThreadsafe(

[taker = std::move(taker),

cpu_usage_stats = std::move(cpu_usage_stats),

err = err](Environment* env) mutable {

Isolate* isolate = env->isolate();

HandleScope handle_scope(isolate);

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

AsyncHooks::DefaultTriggerAsyncIdScope trigger_id_scope(taker.get());

Local<Value> argv[] = {

Null(isolate),

Undefined(isolate),

};

if (err) {

argv[0] = UVException(

isolate, err, "uv_getrusage_thread", nullptr, nullptr, nullptr);

} else {

Local<Name> names[] = {

FIXED_ONE_BYTE_STRING(isolate, "user"),

FIXED_ONE_BYTE_STRING(isolate, "system"),

};

Local<Value> values[] = {

Number::New(isolate,

1e6 * cpu_usage_stats->ru_utime.tv_sec +

cpu_usage_stats->ru_utime.tv_usec),

Number::New(isolate,

1e6 * cpu_usage_stats->ru_stime.tv_sec +

cpu_usage_stats->ru_stime.tv_usec),

};

argv[1] = Object::New(

isolate, Null(isolate), names, values, arraysize(names));

}

taker->MakeCallback(env->ondone_string(), arraysize(argv), argv);

},

CallbackFlags::kUnrefed);

});

if (scheduled) {

args.GetReturnValue().Set(wrap);

}

}

class WorkerHeapStatisticsTaker : public AsyncWrap {

public:

WorkerHeapStatisticsTaker(Environment* env, Local<Object> obj)

SetProtoMethod(isolate, w, "loopIdleTime", Worker::LoopIdleTime);

SetProtoMethod(isolate, w, "loopStartTime", Worker::LoopStartTime);

SetProtoMethod(isolate, w, "getHeapStatistics", Worker::GetHeapStatistics);

SetProtoMethod(isolate, w, "cpuUsage", Worker::CpuUsage);

SetConstructorFunction(isolate, target, "Worker", w);

}

wst->InstanceTemplate());

}

{

Local<FunctionTemplate> wst = NewFunctionTemplate(isolate, nullptr);

wst->InstanceTemplate()->SetInternalFieldCount(

WorkerCpuUsageTaker::kInternalFieldCount);

wst->Inherit(AsyncWrap::GetConstructorTemplate(isolate_data));

Local<String> wst_string =

FIXED_ONE_BYTE_STRING(isolate, "WorkerCpuUsageTaker");

wst->SetClassName(wst_string);

isolate_data->set_worker_cpu_usage_taker_template(wst->InstanceTemplate());

}

SetMethod(isolate, target, "getEnvMessagePort", GetEnvMessagePort);

}

registry->Register(Worker::LoopIdleTime);

registry->Register(Worker::LoopStartTime);

registry->Register(Worker::GetHeapStatistics);

registry->Register(Worker::CpuUsage);

}

} // anonymous namespace