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)                                                                    \