async_hooks: proper id stacking for Promises

Until now, the async_hooks PromiseHook did not register the Promise’s async id and trigger id on the id stack, so inside the `.then()` handler those ids would be invalid. To fix this, add push and pop calls to its `before` and `after` parts, respectively. Some care needs to be taken for the cases that the Promise hook is being disabled or enabled during the execution of a Promise handler; in the former case, actually removing the hook is delayed by adding another task to the microtask queue, in the latter case popping the id off the async id stack is skipped if the ids don’t match. Fixes: #13583 PR-URL: #13585 Reviewed-By: Trevor Norris <[email protected]>

Author: addaleax

src/async-wrap.cc

@@ -333,12 +333,7 @@ void PromiseWrap::GetParentId(Local<String> property,
 
 staticvoidPromiseHook(PromiseHookType type, Local<Promise> promise,
  Local<Value> parent, void* arg){
- Local<Context> context = promise->CreationContext();
- Environment* env = Environment::GetCurrent(context);
-
-// PromiseHook() should never be called if no hooks have been enabled.
-CHECK_GT(env->async_hooks()->fields()[AsyncHooks::kTotals], 0);
-
+ Environment* env = static_cast<Environment*>(arg);
  Local<Value> resource_object_value = promise->GetInternalField(0);
  PromiseWrap* wrap = nullptr;
 if (resource_object_value->IsObject()){
@@ -376,9 +371,18 @@ static void PromiseHook(PromiseHookType type, Local<Promise> promise,
 
 CHECK_NE(wrap, nullptr);
 if (type == PromiseHookType::kBefore){
+ env->async_hooks()->push_ids(wrap->get_id(), wrap->get_trigger_id());
 PreCallbackExecution(wrap, false);
  } elseif (type == PromiseHookType::kAfter){
 PostCallbackExecution(wrap, false);
+if (env->current_async_id() == wrap->get_id()){
+// This condition might not be true if async_hooks was enabled during
+// the promise callback execution.
+// Popping it off the stack can be skipped in that case, because is is
+// known that it would correspond to exactly one call with
+// PromiseHookType::kBefore that was not witnessed by the PromiseHook.
+ env->async_hooks()->pop_ids(wrap->get_id());
+ }
  }
 }
 
@@ -429,13 +433,19 @@ static void SetupHooks(const FunctionCallbackInfo<Value>& args){
 
 staticvoidEnablePromiseHook(const FunctionCallbackInfo<Value>& args){
  Environment* env = Environment::GetCurrent(args);
- env->AddPromiseHook(PromiseHook, nullptr);
+ env->AddPromiseHook(PromiseHook, static_cast<void*>(env));
 }
 
 
 staticvoidDisablePromiseHook(const FunctionCallbackInfo<Value>& args){
  Environment* env = Environment::GetCurrent(args);
- env->RemovePromiseHook(PromiseHook, nullptr);
+
+// Delay the call to `RemovePromiseHook` because we might currently be
+// between the `before` and `after` calls of a Promise.
+ env->isolate()->EnqueueMicrotask([](void* data){
+ Environment* env = static_cast<Environment*>(data);
+ env->RemovePromiseHook(PromiseHook, data);
+ }, static_cast<void*>(env));
 }
 
 

src/env.cc

@@ -184,8 +184,11 @@ void Environment::AddPromiseHook(promise_hook_func fn, void* arg){
  [&](const PromiseHookCallback& hook){
 return hook.cb_ == fn && hook.arg_ == arg;
  });
-CHECK_EQ(it, promise_hooks_.end());
- promise_hooks_.push_back(PromiseHookCallback{fn, arg});
+if (it != promise_hooks_.end()){
+ it->enable_count_++;
+return;
+ }
+ promise_hooks_.push_back(PromiseHookCallback{fn, arg, 1});
 
 if (promise_hooks_.size() == 1){
  isolate_->SetPromiseHook(EnvPromiseHook);
@@ -201,6 +204,8 @@ bool Environment::RemovePromiseHook(promise_hook_func fn, void* arg){
 
 if (it == promise_hooks_.end()) returnfalse;
 
+if (--it->enable_count_ > 0) returntrue;
+
  promise_hooks_.erase(it);
 if (promise_hooks_.empty()){
  isolate_->SetPromiseHook(nullptr);

src/env.h

@@ -709,6 +709,7 @@ class Environment{
 structPromiseHookCallback{
  promise_hook_func cb_;
 void* arg_;
+size_t enable_count_;
  };
  std::vector<PromiseHookCallback> promise_hooks_;
 

test/addons/async-hooks-promise/test.js

@@ -36,8 +36,12 @@ assert.strictEqual(
 
 hook1.disable();
 
-// Check that internal fields are no longer being set.
-assert.strictEqual(
-binding.getPromiseField(Promise.resolve(1)),
-0,
-'Promise internal field used despite missing enabled AsyncHook');
+// Check that internal fields are no longer being set. This needs to be delayed
+// a bit because the `disable()` call only schedules disabling the hook in a
+// future microtask.
+setImmediate(()=>{
+assert.strictEqual(
+binding.getPromiseField(Promise.resolve(1)),
+0,
+'Promise internal field used despite missing enabled AsyncHook');
+});

test/parallel/test-async-hooks-disable-during-promise.js

@@ -0,0 +1,17 @@
+'use strict';
+constcommon=require('../common');
+constasync_hooks=require('async_hooks');
+
+consthook=async_hooks.createHook({
+init: common.mustCall(2),
+before: common.mustCall(1),
+after: common.mustNotCall()
+}).enable();
+
+Promise.resolve(1).then(common.mustCall(()=>{
+hook.disable();
+
+Promise.resolve(42).then(common.mustCall());
+
+process.nextTick(common.mustCall());
+}));

test/parallel/test-async-hooks-enable-during-promise.js

@@ -0,0 +1,13 @@
+'use strict';
+constcommon=require('../common');
+constasync_hooks=require('async_hooks');
+
+Promise.resolve(1).then(common.mustCall(()=>{
+async_hooks.createHook({
+init: common.mustCall(),
+before: common.mustCall(),
+after: common.mustCall(2)
+}).enable();
+
+process.nextTick(common.mustCall());
+}));

test/parallel/test-async-hooks-promise-triggerid.js

@@ -0,0 +1,32 @@
+'use strict';
+constcommon=require('../common');
+constassert=require('assert');
+constasync_hooks=require('async_hooks');
+
+common.crashOnUnhandledRejection();
+
+constpromiseAsyncIds=[];
+
+async_hooks.createHook({
+init: common.mustCallAtLeast((id,type,triggerId)=>{
+if(type==='PROMISE'){
+// Check that the last known Promise is triggering the creation of
+// this one.
+assert.strictEqual(promiseAsyncIds[promiseAsyncIds.length-1]||1,
+triggerId);
+promiseAsyncIds.push(id);
+}
+},3),
+before: common.mustCall((id)=>{
+assert.strictEqual(id,promiseAsyncIds[1]);
+}),
+after: common.mustCall((id)=>{
+assert.strictEqual(id,promiseAsyncIds[1]);
+})
+}).enable();
+
+Promise.resolve(42).then(common.mustCall(()=>{
+assert.strictEqual(async_hooks.executionAsyncId(),promiseAsyncIds[1]);
+assert.strictEqual(async_hooks.triggerAsyncId(),promiseAsyncIds[0]);
+Promise.resolve(10);
+}));