async_hooks: rename initTriggerId

rename initTriggerId to defaultTriggerAsyncId such it matches the rest
of our naming.

PR-URL: https://github.com/nodejs/node/pull/17273
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>

lib/_http_client.js

@@ -547,7 +547,7 @@ function responseKeepAlive(res, req) {
     socket.removeListener('error', socketErrorListener);
     socket.once('error', freeSocketErrorListener);
     // There are cases where _handle === null. Avoid those. Passing null to
-    // nextTick() will call initTriggerId() to retrieve the id.
+    // nextTick() will call getDefaultTriggerAsyncId() to retrieve the id.
     const asyncId = socket._handle ? socket._handle.getAsyncId() : null;
     // Mark this socket as available, AFTER user-added end
     // handlers have a chance to run.

lib/async_hooks.js

@@ -15,7 +15,7 @@ const {
   disableHooks,
   // Internal Embedder API
   newUid,
-  initTriggerId,
+  getDefaultTriggerAsyncId,
   emitInit,
   emitBefore,
   emitAfter,
@@ -147,7 +147,7 @@ class AsyncResource {
     if (typeof opts === 'number') {
       opts = { triggerAsyncId: opts, requireManualDestroy: false };
     } else if (opts.triggerAsyncId === undefined) {
-      opts.triggerAsyncId = initTriggerId();
+      opts.triggerAsyncId = getDefaultTriggerAsyncId();
     }
 
     // Unlike emitInitScript, AsyncResource doesn't supports null as the

lib/dgram.js

@@ -28,7 +28,7 @@ const dns = require('dns');
 const util = require('util');
 const { isUint8Array } = require('internal/util/types');
 const EventEmitter = require('events');
-const { setInitTriggerId } = require('internal/async_hooks');
+const { setDefaultTriggerAsyncId } = require('internal/async_hooks');
 const { UV_UDP_REUSEADDR } = process.binding('constants').os;
 const { async_id_symbol } = process.binding('async_wrap');
 const { nextTick } = require('internal/process/next_tick');
@@ -481,7 +481,7 @@ function doSend(ex, self, ip, list, address, port, callback) {
   // node::SendWrap isn't instantiated and attached to the JS instance of
   // SendWrap above until send() is called. So don't set the init trigger id
   // until now.
-  setInitTriggerId(self[async_id_symbol]);
+  setDefaultTriggerAsyncId(self[async_id_symbol]);
   var err = self._handle.send(req,
                               list,
                               list.length,

lib/internal/async_hooks.js

@@ -14,10 +14,10 @@ const async_wrap = process.binding('async_wrap');
  *  kTriggerAsyncId: The trigger_async_id of the resource responsible for
  *    the current execution stack.
  *  kAsyncIdCounter: Incremental counter tracking the next assigned async_id.
- *  kInitTriggerAsyncId: Written immediately before a resource's constructor
+ *  kDefaultTriggerAsyncId: Written immediately before a resource's constructor
  *    that sets the value of the init()'s triggerAsyncId. The order of
  *    retrieving the triggerAsyncId value is passing directly to the
- *    constructor -> value set in kInitTriggerAsyncId -> executionAsyncId of
+ *    constructor -> value set in kDefaultTriggerAsyncId -> executionAsyncId of
  *    the current resource.
  */
 const { async_hook_fields, async_id_fields } = async_wrap;
@@ -61,7 +61,7 @@ const active_hooks = {
 // for a given step, that step can bail out early.
 const { kInit, kBefore, kAfter, kDestroy, kPromiseResolve,
         kCheck, kExecutionAsyncId, kAsyncIdCounter,
-        kInitTriggerAsyncId } = async_wrap.constants;
+        kDefaultTriggerAsyncId } = async_wrap.constants;
 
 // Used in AsyncHook and AsyncResource.
 const init_symbol = Symbol('init');
@@ -245,25 +245,25 @@ function newUid() {
   return ++async_id_fields[kAsyncIdCounter];
 }
 
-
 // Return the triggerAsyncId meant for the constructor calling it. It's up to
 // the user to safeguard this call and make sure it's zero'd out when the
 // constructor is complete.
-function initTriggerId() {
-  var triggerAsyncId = async_id_fields[kInitTriggerAsyncId];
+function getDefaultTriggerAsyncId() {
+  var defaultTriggerAsyncId = async_id_fields[kDefaultTriggerAsyncId];
   // Reset value after it's been called so the next constructor doesn't
   // inherit it by accident.
-  async_id_fields[kInitTriggerAsyncId] = 0;
-  if (triggerAsyncId <= 0)
-    triggerAsyncId = async_id_fields[kExecutionAsyncId];
-  return triggerAsyncId;
+  async_id_fields[kDefaultTriggerAsyncId] = 0;
+  // If defaultTriggerAsyncId isn't set, use the executionAsyncId
+  if (defaultTriggerAsyncId <= 0)
+    defaultTriggerAsyncId = async_id_fields[kExecutionAsyncId];
+  return defaultTriggerAsyncId;
 }
 
 
-function setInitTriggerId(triggerAsyncId) {
+function setDefaultTriggerAsyncId(triggerAsyncId) {
   // CHECK(Number.isSafeInteger(triggerAsyncId))
   // CHECK(triggerAsyncId > 0)
-  async_id_fields[kInitTriggerAsyncId] = triggerAsyncId;
+  async_id_fields[kDefaultTriggerAsyncId] = triggerAsyncId;
 }
 
 
@@ -282,13 +282,13 @@ function emitInitScript(asyncId, type, triggerAsyncId, resource) {
     return;
 
   // This can run after the early return check b/c running this function
-  // manually means that the embedder must have used initTriggerId().
+  // manually means that the embedder must have used getDefaultTriggerAsyncId().
   if (triggerAsyncId === null) {
-    triggerAsyncId = initTriggerId();
+    triggerAsyncId = getDefaultTriggerAsyncId();
   } else {
-    // If a triggerAsyncId was passed, any kInitTriggerAsyncId still must be
+    // If a triggerAsyncId was passed, any kDefaultTriggerAsyncId still must be
     // null'd.
-    async_id_fields[kInitTriggerAsyncId] = 0;
+    async_id_fields[kDefaultTriggerAsyncId] = 0;
   }
 
   emitInitNative(asyncId, type, triggerAsyncId, resource);
@@ -340,8 +340,8 @@ module.exports = {
   disableHooks,
   // Internal Embedder API
   newUid,
-  initTriggerId,
-  setInitTriggerId,
+  getDefaultTriggerAsyncId,
+  setDefaultTriggerAsyncId,
   emitInit: emitInitScript,
   emitBefore: emitBeforeScript,
   emitAfter: emitAfterScript,

lib/internal/bootstrap_node.js

@@ -369,14 +369,14 @@
     // Internal functions needed to manipulate the stack.
     const { clearAsyncIdStack, asyncIdStackSize } = async_wrap;
     const { kAfter, kExecutionAsyncId,
-            kInitTriggerAsyncId } = async_wrap.constants;
+            kDefaultTriggerAsyncId } = async_wrap.constants;
 
     process._fatalException = function(er) {
       var caught;
 
-      // It's possible that kInitTriggerAsyncId was set for a constructor call
-      // that threw and was never cleared. So clear it now.
-      async_id_fields[kInitTriggerAsyncId] = 0;
+      // It's possible that kDefaultTriggerAsyncId was set for a constructor
+      // call that threw and was never cleared. So clear it now.
+      async_id_fields[kDefaultTriggerAsyncId] = 0;
 
       if (exceptionHandlerState.captureFn !== null) {
         exceptionHandlerState.captureFn(er);

lib/internal/process/next_tick.js

@@ -48,7 +48,7 @@ function setupNextTick() {
   const promises = require('internal/process/promises');
   const errors = require('internal/errors');
   const emitPendingUnhandledRejections = promises.setup(scheduleMicrotasks);
-  const initTriggerId = async_hooks.initTriggerId;
+  const getDefaultTriggerAsyncId = async_hooks.getDefaultTriggerAsyncId;
   // Two arrays that share state between C++ and JS.
   const { async_hook_fields, async_id_fields } = async_wrap;
   // Used to change the state of the async id stack.
@@ -210,7 +210,7 @@ function setupNextTick() {
     nextTickQueue.push(new TickObject(callback,
                                       args,
                                       ++async_id_fields[kAsyncIdCounter],
-                                      initTriggerId()));
+                                      getDefaultTriggerAsyncId()));
   }
 
   // `internalNextTick()` will not enqueue any callback when the process is
@@ -237,7 +237,7 @@ function setupNextTick() {
     }
 
     if (triggerAsyncId === null)
-      triggerAsyncId = initTriggerId();
+      triggerAsyncId = getDefaultTriggerAsyncId();
     // In V8 6.2, moving tickInfo & async_id_fields[kAsyncIdCounter] into the
     // TickObject incurs a significant performance penalty in the
     // next-tick-breadth-args benchmark (revisit later)

lib/net.js

@@ -43,7 +43,7 @@ const { TCPConnectWrap } = process.binding('tcp_wrap');
 const { PipeConnectWrap } = process.binding('pipe_wrap');
 const { ShutdownWrap, WriteWrap } = process.binding('stream_wrap');
 const { async_id_symbol } = process.binding('async_wrap');
-const { newUid, setInitTriggerId } = require('internal/async_hooks');
+const { newUid, setDefaultTriggerAsyncId } = require('internal/async_hooks');
 const { nextTick } = require('internal/process/next_tick');
 const errors = require('internal/errors');
 const dns = require('dns');
@@ -304,7 +304,7 @@ function onSocketFinish() {
   // node::ShutdownWrap isn't instantiated and attached to the JS instance of
   // ShutdownWrap above until shutdown() is called. So don't set the init
   // trigger id until now.
-  setInitTriggerId(this[async_id_symbol]);
+  setDefaultTriggerAsyncId(this[async_id_symbol]);
   var err = this._handle.shutdown(req);
 
   if (err)
@@ -948,7 +948,7 @@ function internalConnect(
     // node::TCPConnectWrap isn't instantiated and attached to the JS instance
     // of TCPConnectWrap above until connect() is called. So don't set the init
     // trigger id until now.
-    setInitTriggerId(self[async_id_symbol]);
+    setDefaultTriggerAsyncId(self[async_id_symbol]);
     if (addressType === 4)
       err = self._handle.connect(req, address, port);
     else
@@ -961,7 +961,7 @@ function internalConnect(
     // node::PipeConnectWrap isn't instantiated and attached to the JS instance
     // of PipeConnectWrap above until connect() is called. So don't set the
     // init trigger id until now.
-    setInitTriggerId(self[async_id_symbol]);
+    setDefaultTriggerAsyncId(self[async_id_symbol]);
     err = self._handle.connect(req, address, afterConnect);
   }
 
@@ -1097,7 +1097,7 @@ function lookupAndConnect(self, options) {
   debug('connect: dns options', dnsopts);
   self._host = host;
   var lookup = options.lookup || dns.lookup;
-  setInitTriggerId(self[async_id_symbol]);
+  setDefaultTriggerAsyncId(self[async_id_symbol]);
   lookup(host, dnsopts, function emitLookup(err, ip, addressType) {
     self.emit('lookup', err, ip, addressType, host);
 

lib/timers.js

@@ -34,7 +34,7 @@ const kOnTimeout = TimerWrap.kOnTimeout | 0;
 // Two arrays that share state between C++ and JS.
 const { async_hook_fields, async_id_fields } = async_wrap;
 const {
-  initTriggerId,
+  getDefaultTriggerAsyncId,
   // The needed emit*() functions.
   emitInit,
   emitBefore,
@@ -181,7 +181,7 @@ function insert(item, unrefed) {
   if (!item[async_id_symbol] || item._destroyed) {
     item._destroyed = false;
     item[async_id_symbol] = ++async_id_fields[kAsyncIdCounter];
-    item[trigger_async_id_symbol] = initTriggerId();
+    item[trigger_async_id_symbol] = getDefaultTriggerAsyncId();
     if (async_hook_fields[kInit] > 0) {
       emitInit(item[async_id_symbol],
                'Timeout',
@@ -560,7 +560,7 @@ function Timeout(callback, after, args, isRepeat) {
   this._destroyed = false;
 
   this[async_id_symbol] = ++async_id_fields[kAsyncIdCounter];
-  this[trigger_async_id_symbol] = initTriggerId();
+  this[trigger_async_id_symbol] = getDefaultTriggerAsyncId();
   if (async_hook_fields[kInit] > 0) {
     emitInit(this[async_id_symbol],
              'Timeout',
@@ -786,7 +786,7 @@ function Immediate(callback, args) {
   this._destroyed = false;
 
   this[async_id_symbol] = ++async_id_fields[kAsyncIdCounter];
-  this[trigger_async_id_symbol] = initTriggerId();
+  this[trigger_async_id_symbol] = getDefaultTriggerAsyncId();
   if (async_hook_fields[kInit] > 0) {
     emitInit(this[async_id_symbol],
              'Immediate',

src/async_wrap.cc

@@ -310,7 +310,7 @@ static void PromiseHook(PromiseHookType type, Local<Promise> promise,
       }
       // get id from parentWrap
       double trigger_async_id = parent_wrap->get_async_id();
-      env->set_init_trigger_async_id(trigger_async_id);
+      env->set_default_trigger_async_id(trigger_async_id);
     }
 
     wrap = PromiseWrap::New(env, promise, parent_wrap, silent);
@@ -542,9 +542,10 @@ void AsyncWrap::Initialize(Local<Object> target,
   //
   // kAsyncUid: Maintains the state of the next unique id to be assigned.
   //
-  // kInitTriggerAsyncId: Write the id of the resource responsible for a
+  // kDefaultTriggerAsyncId: Write the id of the resource responsible for a
   //   handle's creation just before calling the new handle's constructor.
-  //   After the new handle is constructed kInitTriggerAsyncId is set back to 0.
+  //   After the new handle is constructed kDefaultTriggerAsyncId is set back
+  //   to 0.
   FORCE_SET_TARGET_FIELD(target,
                          "async_id_fields",
                          env->async_hooks()->async_id_fields().GetJSArray());
@@ -564,7 +565,7 @@ void AsyncWrap::Initialize(Local<Object> target,
   SET_HOOKS_CONSTANT(kExecutionAsyncId);
   SET_HOOKS_CONSTANT(kTriggerAsyncId);
   SET_HOOKS_CONSTANT(kAsyncIdCounter);
-  SET_HOOKS_CONSTANT(kInitTriggerAsyncId);
+  SET_HOOKS_CONSTANT(kDefaultTriggerAsyncId);
 #undef SET_HOOKS_CONSTANT
   FORCE_SET_TARGET_FIELD(target, "constants", constants);
 
@@ -677,7 +678,7 @@ void AsyncWrap::EmitDestroy(Environment* env, double async_id) {
 void AsyncWrap::AsyncReset(double execution_async_id, bool silent) {
   async_id_ =
     execution_async_id == -1 ? env()->new_async_id() : execution_async_id;
-  trigger_async_id_ = env()->get_init_trigger_async_id();
+  trigger_async_id_ = env()->get_default_trigger_async_id();
 
   switch (provider_type()) {
 #define V(PROVIDER)                                                           \
@@ -778,7 +779,7 @@ async_context EmitAsyncInit(Isolate* isolate,
 
   // Initialize async context struct
   if (trigger_async_id == -1)
-    trigger_async_id = env->get_init_trigger_async_id();
+    trigger_async_id = env->get_default_trigger_async_id();
 
   async_context context = {
     env->new_async_id(),  // async_id_

src/connection_wrap.cc

@@ -49,7 +49,7 @@ void ConnectionWrap<WrapType, UVType>::OnConnection(uv_stream_t* handle,
   };
 
   if (status == 0) {
-    env->set_init_trigger_async_id(wrap_data->get_async_id());
+    env->set_default_trigger_async_id(wrap_data->get_async_id());
     // Instantiate the client javascript object and handle.
     Local<Object> client_obj = WrapType::Instantiate(env,
                                                      wrap_data,

src/env-inl.h

@@ -447,17 +447,18 @@ inline double Environment::trigger_async_id() {
   return async_hooks()->async_id_fields()[AsyncHooks::kTriggerAsyncId];
 }
 
-inline double Environment::get_init_trigger_async_id() {
-  AliasedBuffer<double, v8::Float64Array>& async_id_fields =
-    async_hooks()->async_id_fields();
-  double tid = async_id_fields[AsyncHooks::kInitTriggerAsyncId];
-  async_id_fields[AsyncHooks::kInitTriggerAsyncId] = 0;
-  if (tid <= 0) tid = execution_async_id();
-  return tid;
+inline double Environment::get_default_trigger_async_id() {
+  double default_trigger_async_id =
+    async_hooks()->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId];
+  async_hooks()->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId] = 0;
+  // If defaultTriggerAsyncId isn't set, use the executionAsyncId
+  if (default_trigger_async_id <= 0)
+    default_trigger_async_id = execution_async_id();
+  return default_trigger_async_id;
 }
 
-inline void Environment::set_init_trigger_async_id(const double id) {
-  async_hooks()->async_id_fields()[AsyncHooks::kInitTriggerAsyncId] = id;
+inline void Environment::set_default_trigger_async_id(const double id) {
+  async_hooks()->async_id_fields()[AsyncHooks::kDefaultTriggerAsyncId] = id;
 }
 
 inline double* Environment::heap_statistics_buffer() const {

src/env.h

@@ -381,7 +381,7 @@ class Environment {
       kExecutionAsyncId,
       kTriggerAsyncId,
       kAsyncIdCounter,
-      kInitTriggerAsyncId,
+      kDefaultTriggerAsyncId,
       kUidFieldsCount,
     };
 
@@ -558,8 +558,8 @@ class Environment {
   inline double new_async_id();
   inline double execution_async_id();
   inline double trigger_async_id();
-  inline double get_init_trigger_async_id();
-  inline void set_init_trigger_async_id(const double id);
+  inline double get_default_trigger_async_id();
+  inline void set_default_trigger_async_id(const double id);
 
   // List of id's that have been destroyed and need the destroy() cb called.
   inline std::vector<double>* destroy_async_id_list();

src/stream_base.cc

@@ -52,7 +52,7 @@ int StreamBase::Shutdown(const FunctionCallbackInfo<Value>& args) {
 
   AsyncWrap* wrap = GetAsyncWrap();
   CHECK_NE(wrap, nullptr);
-  env->set_init_trigger_async_id(wrap->get_async_id());
+  env->set_default_trigger_async_id(wrap->get_async_id());
   ShutdownWrap* req_wrap = new ShutdownWrap(env,
                                             req_wrap_obj,
                                             this);
@@ -155,7 +155,7 @@ int StreamBase::Writev(const FunctionCallbackInfo<Value>& args) {
 
   wrap = GetAsyncWrap();
   CHECK_NE(wrap, nullptr);
-  env->set_init_trigger_async_id(wrap->get_async_id());
+  env->set_default_trigger_async_id(wrap->get_async_id());
   req_wrap = WriteWrap::New(env, req_wrap_obj, this, storage_size);
 
   offset = 0;
@@ -245,7 +245,7 @@ int StreamBase::WriteBuffer(const FunctionCallbackInfo<Value>& args) {
 
   wrap = GetAsyncWrap();
   if (wrap != nullptr)
-    env->set_init_trigger_async_id(wrap->get_async_id());
+    env->set_default_trigger_async_id(wrap->get_async_id());
   // Allocate, or write rest
   req_wrap = WriteWrap::New(env, req_wrap_obj, this);
 
@@ -331,7 +331,7 @@ int StreamBase::WriteString(const FunctionCallbackInfo<Value>& args) {
 
   wrap = GetAsyncWrap();
   if (wrap != nullptr)
-    env->set_init_trigger_async_id(wrap->get_async_id());
+    env->set_default_trigger_async_id(wrap->get_async_id());
   req_wrap = WriteWrap::New(env, req_wrap_obj, this, storage_size);
 
   data = req_wrap->Extra();

src/tcp_wrap.cc

@@ -292,7 +292,7 @@ void TCPWrap::Connect(const FunctionCallbackInfo<Value>& args) {
   int err = uv_ip4_addr(*ip_address, port, &addr);
 
   if (err == 0) {
-    env->set_init_trigger_async_id(wrap->get_async_id());
+    env->set_default_trigger_async_id(wrap->get_async_id());
     ConnectWrap* req_wrap =
         new ConnectWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_TCPCONNECTWRAP);
     err = uv_tcp_connect(req_wrap->req(),
@@ -328,7 +328,7 @@ void TCPWrap::Connect6(const FunctionCallbackInfo<Value>& args) {
   int err = uv_ip6_addr(*ip_address, port, &addr);
 
   if (err == 0) {
-    env->set_init_trigger_async_id(wrap->get_async_id());
+    env->set_default_trigger_async_id(wrap->get_async_id());
     ConnectWrap* req_wrap =
         new ConnectWrap(env, req_wrap_obj, AsyncWrap::PROVIDER_TCPCONNECTWRAP);
     err = uv_tcp_connect(req_wrap->req(),

src/udp_wrap.cc

@@ -357,7 +357,7 @@ void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {
   node::Utf8Value address(env->isolate(), args[4]);
   const bool have_callback = args[5]->IsTrue();
 
-  env->set_init_trigger_async_id(wrap->get_async_id());
+  env->set_default_trigger_async_id(wrap->get_async_id());
   SendWrap* req_wrap = new SendWrap(env, req_wrap_obj, have_callback);
   size_t msg_size = 0;