async_hooks: add getActiveResources (prototype)

Prototype of a new getActiveResources() API for async_hooks.

Returns an object map of { <id>: <resource> }, and differs slightly from getActiveHandles().

Currently, it works for all async_hooks resources except nextTick-s, which are probably not useful to expose in this way.

Author: Fishrock123

lib/async_hooks.js

@@ -23,6 +23,7 @@ const {
   validateString,
 } = require('internal/validators');
 const internal_async_hooks = require('internal/async_hooks');
+const internalTimers = require('internal/timers');
 
 // Get functions
 // For userland AsyncResources, make sure to emit a destroy event when the
@@ -148,6 +149,35 @@ function createHook(fns) {
 }
 
 
+function getActiveResources() {
+  const handles = process._getActiveHandles();
+  const reqs = process._getActiveRequests();
+
+  const timers = {};
+  for (const list of Object.values(internalTimers.timerLists)) {
+    var timer = list._idlePrev === list ? null : list._idlePrev;
+
+    while (timer !== null) {
+      timers[timer[internalTimers.async_id_symbol]] = timer;
+
+      timer = timer._idlePrev === list ? null : list._idlePrev;
+    }
+  }
+
+  const immediates = {};
+  const queue = internalTimers.outstandingQueue.head !== null ?
+    internalTimers.outstandingQueue : internalTimers.immediateQueue;
+  var immediate = queue.head;
+  while (immediate !== null) {
+    immediates[immediate[internalTimers.async_id_symbol]] = immediate;
+
+    immediate = immediate._idleNext;
+  }
+
+  return Object.assign({}, handles, reqs, timers, immediates);
+}
+
+
 // Embedder API //
 
 const destroyedSymbol = Symbol('destroyed');
@@ -348,6 +378,7 @@ module.exports = {
   executionAsyncId,
   triggerAsyncId,
   executionAsyncResource,
+  getActiveResources,
   // Embedder API
   AsyncResource,
 };

lib/internal/timers.js

@@ -136,9 +136,59 @@ let timerListId = NumberMIN_SAFE_INTEGER;
 
 const kRefed = Symbol('refed');
 
+// Object map containing linked lists of timers, keyed and sorted by their
+// duration in milliseconds.
+//
+// - key = time in milliseconds
+// - value = linked list
+const timerLists = Object.create(null);
+
+// A linked list for storing `setImmediate()` requests
+function ImmediateList() {
+  this.head = null;
+  this.tail = null;
+}
+
+// Appends an item to the end of the linked list, adjusting the current tail's
+// previous and next pointers where applicable
+ImmediateList.prototype.append = function(item) {
+  if (this.tail !== null) {
+    this.tail._idleNext = item;
+    item._idlePrev = this.tail;
+  } else {
+    this.head = item;
+  }
+  this.tail = item;
+};
+
+// Removes an item from the linked list, adjusting the pointers of adjacent
+// items and the linked list's head or tail pointers as necessary
+ImmediateList.prototype.remove = function(item) {
+  if (item._idleNext !== null) {
+    item._idleNext._idlePrev = item._idlePrev;
+  }
+
+  if (item._idlePrev !== null) {
+    item._idlePrev._idleNext = item._idleNext;
+  }
+
+  if (item === this.head)
+    this.head = item._idleNext;
+  if (item === this.tail)
+    this.tail = item._idlePrev;
+
+  item._idleNext = null;
+  item._idlePrev = null;
+};
+
 // Create a single linked list instance only once at startup
 const immediateQueue = new ImmediateList();
 
+// If an uncaught exception was thrown during execution of immediateQueue,
+// this queue will store all remaining Immediates that need to run upon
+// resolution of all error handling (if process is still alive).
+const outstandingQueue = new ImmediateList();
+
 let nextExpiry = Infinity;
 let refCount = 0;
 
@@ -649,6 +699,7 @@ module.exports = {
   setUnrefTimeout,
   getTimerDuration,
   immediateQueue,
+  outstandingQueue,
   getTimerCallbacks,
   immediateInfoFields: {
     kCount,
@@ -658,6 +709,7 @@ module.exports = {
   active,
   unrefActive,
   insert,
+  timerLists,
   timerListMap,
   timerListQueue,
   decRefCount,

lib/timers.js

@@ -50,7 +50,10 @@ const {
   immediateQueue,
   active,
   unrefActive,
-  insert
+  insert,
+  timerLists: lists,
+  immediateQueue,
+  outstandingQueue,
 } = require('internal/timers');
 const {
   promisify: { custom: customPromisify },

src/node_process_methods.cc

@@ -251,31 +251,42 @@ static void Uptime(const FunctionCallbackInfo<Value>& args) {
 static void GetActiveRequests(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
-  std::vector<Local<Value>> request_v;
-  for (ReqWrapBase* req_wrap : *env->req_wrap_queue()) {
-    AsyncWrap* w = req_wrap->GetAsyncWrap();
+  Local<Context> ctx = env->context();
+  Local<Object> return_obj = Object::New(args.GetIsolate());
+
+  for (auto w : *env->req_wrap_queue()) {
     if (w->persistent().IsEmpty())
       continue;
-    request_v.emplace_back(w->GetOwner());
+    double async_id = w->get_async_id();
+    Local<Object> req_obj = w->object();
+
+    return_obj->Set(ctx, Number::New(args.GetIsolate(), async_id), req_obj);
   }
 
-  args.GetReturnValue().Set(
-      Array::New(env->isolate(), request_v.data(), request_v.size()));
+  args.GetReturnValue().Set(return_obj);
 }
 
 // Non-static, friend of HandleWrap. Could have been a HandleWrap method but
 // implemented here for consistency with GetActiveRequests().
 void GetActiveHandles(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
-  std::vector<Local<Value>> handle_v;
+  Local<Context> ctx = env->context();
+  Local<Object> return_obj = Object::New(args.GetIsolate());
+
+  Local<String> owner_sym = env->owner_string();
+
   for (auto w : *env->handle_wrap_queue()) {
-    if (!HandleWrap::HasRef(w))
+    if (w->persistent().IsEmpty() || !HandleWrap::HasRef(w))
       continue;
-    handle_v.emplace_back(w->GetOwner());
+    double async_id = w->get_async_id();
+    Local<Object> handle_object = w->object();
+    return_obj->Set(ctx, Number::New(args.GetIsolate(),
+                                     async_id),
+                                     handle_object);
   }
-  args.GetReturnValue().Set(
-      Array::New(env->isolate(), handle_v.data(), handle_v.size()));
+
+  args.GetReturnValue().Set(return_obj);
 }
 
 static void ResourceUsage(const FunctionCallbackInfo<Value>& args) {

…rallel/test-process-getactiverequests.js …ync-hooks-getactiveresources-requests.jstest/parallel/test-process-getactiverequests.js renamed to test/parallel/test-async-hooks-getactiveresources-requests.js test/parallel/test-process-getactiverequests.js renamed to test/parallel/test-async-hooks-getactiveresources-requests.js

@@ -3,8 +3,9 @@
 const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
+const { getActiveResources } = require('async_hooks');
 
 for (let i = 0; i < 12; i++)
   fs.open(__filename, 'r', common.mustCall());
 
-assert.strictEqual(process._getActiveRequests().length, 12);
+assert.strictEqual(12, Object.values(getActiveResources()).length);

…arallel/test-process-getactivehandles.js …l/test-async-hooks-getactiveresources.jstest/parallel/test-process-getactivehandles.js renamed to test/parallel/test-async-hooks-getactiveresources.js test/parallel/test-process-getactivehandles.js renamed to test/parallel/test-async-hooks-getactiveresources.js

@@ -3,6 +3,8 @@
 require('../common');
 const assert = require('assert');
 const net = require('net');
+const { getActiveResources } = require('async_hooks');
+
 const NUM = 8;
 const connections = [];
 const clients = [];
@@ -30,18 +32,18 @@ function clientConnected(client) {
 
 
 function checkAll() {
-  const handles = process._getActiveHandles();
+  const handles = Object.values(getActiveResources());
 
   clients.forEach(function(item) {
-    assert.ok(handles.includes(item));
+    assert.ok(handles.includes(item._handle));
     item.destroy();
   });
 
   connections.forEach(function(item) {
-    assert.ok(handles.includes(item));
+    assert.ok(handles.includes(item._handle));
     item.end();
   });
 
-  assert.ok(handles.includes(server));
+  assert.ok(handles.includes(server._handle));
   server.close();
 }

test/parallel/test-handle-wrap-isrefed.js

@@ -4,6 +4,7 @@
 const common = require('../common');
 const strictEqual = require('assert').strictEqual;
 const { internalBinding } = require('internal/test/binding');
+const { getActiveResources } = require('async_hooks');
 
 // child_process
 {
@@ -107,4 +108,25 @@ const { kStateSymbol } = require('internal/dgram');
 }
 
 
+// timers
+{
+  const { Timer } = process.binding('timer_wrap');
+  strictEqual(Object.values(getActiveResources()).filter(
+    (handle) => (handle instanceof Timer)).length, 0);
+  const timer = setTimeout(() => {}, 500);
+  const handles = Object.values(getActiveResources()).filter(
+    (handle) => (handle instanceof Timer));
+  strictEqual(handles.length, 1);
+  const handle = handles[0];
+  strictEqual(Object.getPrototypeOf(handle).hasOwnProperty('hasRef'),
+              true, 'timer_wrap: hasRef() missing');
+  strictEqual(handle.hasRef(), true);
+  timer.unref();
+  strictEqual(handle.hasRef(),
+              false, 'timer_wrap: unref() ineffective');
+  timer.ref();
+  strictEqual(handle.hasRef(),
+              true, 'timer_wrap: ref() ineffective');
+}
+
 // See also test/pseudo-tty/test-handle-wrap-isrefed-tty.js

test/pseudo-tty/ref_keeps_node_running.js

@@ -6,6 +6,7 @@ require('../common');
 const { internalBinding } = require('internal/test/binding');
 const { TTY, isTTY } = internalBinding('tty_wrap');
 const strictEqual = require('assert').strictEqual;
+const { getActiveResources } = require('async_hooks');
 
 strictEqual(isTTY(0), true, 'fd 0 is not a TTY');
 
@@ -14,7 +15,8 @@ handle.readStart();
 handle.onread = () => {};
 
 function isHandleActive(handle) {
-  return process._getActiveHandles().some((active) => active === handle);
+  return Object.values(getActiveResources())
+    .some((active) => active === handle);
 }
 
 strictEqual(isHandleActive(handle), true, 'TTY handle not initially active');