async-wrap: always call before and after hooks

src/async-wrap-inl.h

@@ -20,8 +20,8 @@ inline AsyncWrap::AsyncWrap(Environment* env,
     : BaseObject(env, object),
       has_async_queue_(false),
       provider_type_(provider) {
-  // Check user controlled flag to see if the init callback should run.
-  if (!env->call_async_init_hook())
+  // Check user controlled flag to see if the async hooks should be called.
+  if (!env->use_async_hook())
     return;
 
   // TODO(trevnorris): Until it's verified all passed object's are not weak,
@@ -42,11 +42,13 @@ inline AsyncWrap::AsyncWrap(Environment* env,
       FatalError("node::AsyncWrap::AsyncWrap", "parent pre hook threw");
   }
 
-  env->async_hooks_init_function()->Call(object, 0, nullptr);
-
-  if (try_catch.HasCaught())
-    FatalError("node::AsyncWrap::AsyncWrap", "init hook threw");
+  // Check user controlled flag to see if the init callback should run.
+  if (env->call_async_init_hook()) {
+    env->async_hooks_init_function()->Call(object, 0, nullptr);
 
+    if (try_catch.HasCaught())
+      FatalError("node::AsyncWrap::AsyncWrap", "init hook threw");
+  }
   has_async_queue_ = true;
 
   if (parent != nullptr) {

src/async-wrap.cc

@@ -45,6 +45,8 @@ static void SetupHooks(const FunctionCallbackInfo<Value>& args) {
       kExternalUint32Array,
       async_hooks->fields_count());
 
+  async_hooks->enabled = true;
+
   env->set_async_hooks_init_function(args[1].As<Function>());
   env->set_async_hooks_pre_function(args[2].As<Function>());
   env->set_async_hooks_post_function(args[3].As<Function>());

src/env-inl.h

@@ -55,6 +55,7 @@ inline v8::Isolate* Environment::IsolateData::isolate() const {
 }
 
 inline Environment::AsyncHooks::AsyncHooks() {
+  enabled = false;
   for (int i = 0; i < kFieldsCount; i++) fields_[i] = 0;
 }
 
@@ -214,6 +215,11 @@ inline v8::Isolate* Environment::isolate() const {
   return isolate_;
 }
 
+inline bool Environment::use_async_hook() const {
+  // The const_cast is okay, it doesn't violate conceptual const-ness.
+  return const_cast<Environment*>(this)->async_hooks()->enabled;
+}
+
 inline bool Environment::call_async_init_hook() const {
   // The const_cast is okay, it doesn't violate conceptual const-ness.
   return const_cast<Environment*>(this)->async_hooks()->call_init_hook();

src/env.h

@@ -255,6 +255,7 @@ class Environment {
     inline uint32_t* fields();
     inline int fields_count() const;
     inline bool call_init_hook();
+    bool enabled;
 
    private:
     friend class Environment;  // So we can call the constructor.
@@ -358,6 +359,7 @@ class Environment {
 
   inline v8::Isolate* isolate() const;
   inline uv_loop_t* event_loop() const;
+  inline bool use_async_hook() const;
   inline bool call_async_init_hook() const;
   inline bool in_domain() const;
   inline uint32_t watched_providers() const;

test/parallel/test-async-wrap-init-hook.js

@@ -0,0 +1,33 @@
+var common = require('../common');
+var assert = require('assert');
+
+var asyncWrap = process.binding('async_wrap');
+
+var asyncHooksObject = {};
+var kCallInitHook = 0;
+asyncWrap.setupHooks(asyncHooksObject, init, before, after);
+asyncHooksObject[kCallInitHook] = 1;
+
+var order = [];
+
+function init() {
+  order.push('init ' + this.constructor.name);
+}
+
+function before() {
+  order.push('before ' + this.constructor.name);
+}
+
+function after() {
+  order.push('after ' + this.constructor.name);
+}
+
+setTimeout(function () {
+  order.push('callback');
+});
+
+process.once('exit', function () {
+  assert.deepEqual(order, [
+    'init Timer', 'before Timer', 'callback', 'after Timer'
+  ]);
+});

test/parallel/test-async-wrap-no-init-hook.js

@@ -0,0 +1,31 @@
+var common = require('../common');
+var assert = require('assert');
+
+var asyncWrap = process.binding('async_wrap');
+
+var asyncHooksObject = {};
+asyncWrap.setupHooks(asyncHooksObject, init, before, after);
+
+var order = [];
+
+function init() {
+  order.push('init ' + this.constructor.name);
+}
+
+function before() {
+  order.push('before ' + this.constructor.name);
+}
+
+function after() {
+  order.push('after ' + this.constructor.name);
+}
+
+setTimeout(function () {
+  order.push('callback');
+});
+
+process.once('exit', function () {
+  assert.deepEqual(order, [
+    'before Timer', 'callback', 'after Timer'
+  ]);
+});