async_hooks: callback trampoline for MakeCallback

lib/domain.js

@@ -42,6 +42,7 @@ const {
  ERR_UNHANDLED_ERROR
 } = require('internal/errors').codes;
 const { createHook } = require('async_hooks');
+const { useDomainTrampoline } = require('internal/async_hooks');
 
 // TODO(addaleax): Use a non-internal solution for this.
 const kWeak = Symbol('kWeak');
@@ -145,7 +146,7 @@ function topLevelDomainCallback(cb, ...args) {
 // another one. The stack is each entered domain.
 let stack = [];
 exports._stack = stack;
-internalBinding('domain').enable(topLevelDomainCallback);
+useDomainTrampoline(topLevelDomainCallback);
 
 function updateExceptionCapture() {
  if (stack.every((domain) => domain.listenerCount('error') === 0)) {

lib/internal/async_hooks.js

@@ -1,15 +1,18 @@
 'use strict';
 
 const {
+ ArrayPrototypeUnshift,
  Error,
  FunctionPrototypeBind,
  ObjectPrototypeHasOwnProperty,
  ObjectDefineProperty,
  Promise,
+ ReflectApply,
  Symbol,
 } = primordials;
 
 const async_wrap = internalBinding('async_wrap');
+const { setCallbackTrampoline } = async_wrap;
 /* async_hook_fields is a Uint32Array wrapping the uint32_t array of
  * Environment::AsyncHooks::fields_[]. Each index tracks the number of active
  * hooks for each type.
@@ -103,6 +106,31 @@ const emitDestroyNative = emitHookFactory(destroy_symbol, 'emitDestroyNative');
 const emitPromiseResolveNative =
  emitHookFactory(promise_resolve_symbol, 'emitPromiseResolveNative');
 
+let domain_cb;
+function useDomainTrampoline(fn) {
+ domain_cb = fn;
+}
+
+function callbackTrampoline(asyncId, cb, ...args) {
+ if (asyncId && hasHooks(kBefore))
+ emitBeforeNative(asyncId);
+
+ let result;
+ if (typeof domain_cb === 'function') {
+ ArrayPrototypeUnshift(args, cb);
+ result = ReflectApply(domain_cb, this, args);
+ } else {
+ result = ReflectApply(cb, this, args);
+ }
+
+ if (asyncId && hasHooks(kAfter))
+ emitAfterNative(asyncId);
+
+ return result;
+}
+
+setCallbackTrampoline(callbackTrampoline);
+
 const topLevelResource = {};
 
 function executionAsyncResource() {
@@ -541,6 +569,7 @@ module.exports = {
  emitAfter: emitAfterScript,
  emitDestroy: emitDestroyScript,
  registerDestroyHook,
+ useDomainTrampoline,
  nativeHooks: {
  init: emitInitNative,
  before: emitBeforeNative,

node.gyp

@@ -583,7 +583,6 @@
  'src/node_contextify.cc',
  'src/node_credentials.cc',
  'src/node_dir.cc',
- 'src/node_domain.cc',
  'src/node_env_var.cc',
  'src/node_errors.cc',
  'src/node_file.cc',

src/api/callback.cc

@@ -158,20 +158,33 @@ MaybeLocal<Value> InternalMakeCallback(Environment* env,
  CHECK(!argv[i].IsEmpty());
 #endif
 
- InternalCallbackScope scope(env, resource, asyncContext);
+ Local<Function> hook_cb = env->async_hooks_callback_trampoline();
+ int flags = InternalCallbackScope::kNoFlags;
+ int hook_count = 0;
+ if (!hook_cb.IsEmpty()) {
+ flags = InternalCallbackScope::kSkipAsyncHooks;
+ AsyncHooks* async_hooks = env->async_hooks();
+ hook_count = async_hooks->fields()[AsyncHooks::kBefore] +
+ async_hooks->fields()[AsyncHooks::kAfter];
+ }
+
+ InternalCallbackScope scope(env, resource, asyncContext, flags);
  if (scope.Failed()) {
  return MaybeLocal<Value>();
  }
 
- Local<Function> domain_cb = env->domain_callback();
  MaybeLocal<Value> ret;
- if (asyncContext.async_id != 0 || domain_cb.IsEmpty()) {
- ret = callback->Call(env->context(), recv, argc, argv);
+
+ if (hook_count != 0) {
+ MaybeStackBuffer<Local<Value>, 16> args(2 + argc);
+ args[0] = v8::Number::New(env->isolate(), asyncContext.async_id);
+ args[1] = callback;
+ for (int i = 0; i < argc; i++) {
+ args[i + 2] = argv[i];
+ }
+ ret = hook_cb->Call(env->context(), recv, args.length(), &args[0]);
  } 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]);
+ ret = callback->Call(env->context(), recv, argc, argv);
  }
 
  if (ret.IsEmpty()) {

src/async_wrap.cc

@@ -552,6 +552,14 @@ void AsyncWrap::QueueDestroyAsyncId(const FunctionCallbackInfo<Value>& args) {
  args[0].As<Number>()->Value());
 }
 
+void AsyncWrap::SetCallbackTrampoline(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+
+ CHECK(args[0]->IsFunction());
+
+ env->set_async_hooks_callback_trampoline(args[0].As<Function>());
+}
+
 Local<FunctionTemplate> AsyncWrap::GetConstructorTemplate(Environment* env) {
  Local<FunctionTemplate> tmpl = env->async_wrap_ctor_template();
  if (tmpl.IsEmpty()) {
@@ -574,6 +582,7 @@ void AsyncWrap::Initialize(Local<Object> target,
  HandleScope scope(isolate);
 
  env->SetMethod(target, "setupHooks", SetupHooks);
+ env->SetMethod(target, "setCallbackTrampoline", SetCallbackTrampoline);
  env->SetMethod(target, "pushAsyncContext", PushAsyncContext);
  env->SetMethod(target, "popAsyncContext", PopAsyncContext);
  env->SetMethod(target, "queueDestroyAsyncId", QueueDestroyAsyncId);

src/async_wrap.h

@@ -140,6 +140,8 @@ class AsyncWrap : public BaseObject {
  static void GetProviderType(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void QueueDestroyAsyncId(
  const v8::FunctionCallbackInfo<v8::Value>& args);
+ static void SetCallbackTrampoline(
+ const v8::FunctionCallbackInfo<v8::Value>& args);
 
  static void EmitAsyncInit(Environment* env,
  v8::Local<v8::Object> object,

src/env.h

@@ -425,13 +425,13 @@ constexpr size_t kFsStatsBufferLength =
 #define ENVIRONMENT_STRONG_PERSISTENT_VALUES(V) \
  V(async_hooks_after_function, v8::Function) \
  V(async_hooks_before_function, v8::Function) \
+ V(async_hooks_callback_trampoline, v8::Function) \
  V(async_hooks_binding, v8::Object) \
  V(async_hooks_destroy_function, v8::Function) \
  V(async_hooks_init_function, v8::Function) \
  V(async_hooks_promise_resolve_function, v8::Function) \
  V(buffer_prototype_object, v8::Object) \
  V(crypto_key_object_constructor, v8::Function) \
- V(domain_callback, v8::Function) \
  V(domexception_function, v8::Function) \
  V(enhance_fatal_stack_after_inspector, v8::Function) \
  V(enhance_fatal_stack_before_inspector, v8::Function) \

src/node_binding.cc

@@ -42,7 +42,6 @@
  V(config) \
  V(contextify) \
  V(credentials) \
- V(domain) \
  V(errors) \
  V(fs) \
  V(fs_dir) \