next_tick: add async_hooks support

Also did: * Turn TickObject() into a function * Split the function in half so it can be inlined * Fix how uid flags are set * Export kScopedTriggerId for use in setupInit()
nodejs · trevnorris · Oct 31, 2016 · Oct 31, 2016 · Sep 28, 2016 · Nov 2, 2016
commit d244d55d53e75e3a83db354ce96e0f893c06155a
diff --git a/lib/async_hooks.js b/lib/async_hooks.js
@@ -37,7 +37,7 @@ const destroy_symbol = Symbol('destroy');
 // The exception is kActiveHooks. Which tracks the total number of AsyncEvents
 // that exist on "active_hooks_array".
 const { kInit, kBefore, kAfter, kDestroy, kActiveHooks, kAsyncUidCntr,
-        kCurrentId, kTriggerId, kScopedTriggerId, kInitTriggerId } =
+        kCurrentId, kTriggerId, kInitTriggerId, kScopedTriggerId } =
             async_wrap.constants;
 
 // Setup the callbacks that node::AsyncWrap will call when there are hooks to

diff --git a/lib/internal/process/next_tick.js b/lib/internal/process/next_tick.js
@@ -3,8 +3,16 @@
 exports.setup = setupNextTick;
 
 function setupNextTick() {
+  const async_wrap = process.binding('async_wrap');
+  const async_hooks = require('async_hooks');
   const promises = require('internal/process/promises');
   const emitPendingUnhandledRejections = promises.setup(scheduleMicrotasks);
+  const initTriggerId = async_hooks.initTriggerId;
+  // Two arrays that share state between C++ and JS.
+  const { async_uid_fields, async_hook_fields } = async_wrap;
+  // Grab the constants necessary for working with internal arrays.
+  const { kInit, kBefore, kAfter, kDestroy, kActiveHooks, kAsyncUidCntr,
+          kCurrentId, kTriggerId } = async_wrap.constants;
   var nextTickQueue = [];
   var microtasksScheduled = false;
 
@@ -44,10 +52,8 @@ function setupNextTick() {
     if (microtasksScheduled)
       return;
 
-    nextTickQueue.push({
-      callback: runMicrotasksCallback,
-      domain: null
-    });
+    nextTickQueue.push(
+        new TickObject(runMicrotasksCallback, undefined, null, true));
 
     tickInfo[kLength]++;
     microtasksScheduled = true;
@@ -89,13 +95,40 @@ function setupNextTick() {
 
     do {
       while (tickInfo[kIndex] < tickInfo[kLength]) {
+        const has_hooks = async_hook_fields[kActiveHooks] > 0;
+        // TODO(trevnorris): These should always be zero if at the bottom of
+        // the stack. Add check somewhere cheaper than here to make sure that's
+        // the case.
+        const prev_id = async_uid_fields[kCurrentId];
+        const prev_trigger_id = async_uid_fields[kTriggerId];
+
         tock = nextTickQueue[tickInfo[kIndex]++];
         callback = tock.callback;
         args = tock.args;
+
+        // Setting these fields manually with the expectation that has_hooks
+        // will almost always be false. Overhead for doing it twice if it is
+        // true is negligible anyway.
+        async_uid_fields[kCurrentId] = tock._asyncId;
+        async_uid_fields[kTriggerId] = tock._triggerId;
+        if (has_hooks && async_hook_fields[kBefore])
+          async_hooks.emitBefore(tock._asyncId, tock._triggerId);
+
         // Using separate callback execution functions allows direct
         // callback invocation with small numbers of arguments to avoid the
         // performance hit associated with using `fn.apply()`
         _combinedTickCallback(args, callback);
+
+        if (has_hooks) {
+          if (async_hook_fields[kAfter])
+            async_hooks.emitAfter(tock._asyncId);
+          if (async_hook_fields[kDestroy])
+            async_hooks.emitDestroy(tock._asyncId);
+        }
+        // TODO(trevnorris): A caught uncaught exception will mess this up.
+        async_uid_fields[kCurrentId] = prev_id;
+        async_uid_fields[kTriggerId] = prev_trigger_id;
+
         if (1e4 < tickInfo[kIndex])
           tickDone();
       }
@@ -110,16 +143,42 @@ function setupNextTick() {
 
     do {
       while (tickInfo[kIndex] < tickInfo[kLength]) {
+        const has_hooks = async_hook_fields[kActiveHooks] > 0;
+        // TODO(trevnorris): These should always be zero if at the bottom of
+        // the stack. Add check somewhere cheaper than here to make sure that's
+        // the case.
+        const prev_id = async_uid_fields[kCurrentId];
+        const prev_trigger_id = async_uid_fields[kTriggerId];
+
         tock = nextTickQueue[tickInfo[kIndex]++];
         callback = tock.callback;
         domain = tock.domain;
         args = tock.args;
         if (domain)
           domain.enter();
+
+        // Setting these fields manually with the expectation that has_hooks
+        // will almost always be false. Overhead for doing it twice if it is
+        // true is negligible anyway.
+        async_uid_fields[kCurrentId] = tock._asyncId;
+        async_uid_fields[kTriggerId] = tock._triggerId;
+        if (has_hooks && async_hook_fields[kBefore])
+          async_hooks.emitBefore(tock._asyncId, tock._triggerId);
+
         // Using separate callback execution functions allows direct
         // callback invocation with small numbers of arguments to avoid the
         // performance hit associated with using `fn.apply()`
         _combinedTickCallback(args, callback);
+
+        if (has_hooks) {
+          if (async_hook_fields[kAfter])
+            async_hooks.emitAfter(tock._asyncId);
+          if (async_hook_fields[kDestroy])
+            async_hooks.emitDestroy(tock._asyncId);
+        }
+        async_uid_fields[kCurrentId] = prev_id;
+        async_uid_fields[kTriggerId] = prev_trigger_id;
+
         if (1e4 < tickInfo[kIndex])
           tickDone();
         if (domain)
@@ -131,6 +190,26 @@ function setupNextTick() {
     } while (tickInfo[kLength] !== 0);
   }
 
+  function TickObject(callback, args, domain, isMicrotask) {
+    this.callback = callback;
+    this.domain = domain;
+    this.args = args;
+    this._asyncId = -1;
+    this._triggerId = -1;
+    if (!isMicrotask)
+      setupInit(this);
+  }
+
+  // This function is for performance reasons. If the code here is placed
+  // directly in TickObject it would be over the maximum character count
+  // to be inlined, and it would suffer a penalty lose.
+  function setupInit(self) {
+    self._asyncId = ++async_uid_fields[kAsyncUidCntr];
+    self._triggerId = initTriggerId();
+    if (async_hook_fields[kInit] > 0)
+      async_hooks.emitInit(self._asyncId, 'TickObject', self._triggerId, self);
+  }
+
   function nextTick(callback) {
     if (typeof callback !== 'function')
       throw new TypeError('callback is not a function');
@@ -145,11 +224,8 @@ function setupNextTick() {
         args[i - 1] = arguments[i];
     }
 
-    nextTickQueue.push({
-      callback,
-      domain: process.domain || null,
-      args
-    });
+    nextTickQueue.push(
+        new TickObject(callback, args, process.domain || null, false));
     tickInfo[kLength]++;
   }
 }