From d8a212590001796cf4a8e9f5a15650f116e4d94d Mon Sep 17 00:00:00 2001
From: Darshan Sen <darshan.sen@postman.com>
Date: Tue, 14 Dec 2021 19:39:08 +0530
Subject: [PATCH] process: add `getActiveResourcesInfo()`

This is supposed to be a public alternative of the private APIs,
`process._getActiveResources()` and `process._getActiveHandles()`. When
called, it returns an array of strings containing the types of the
active resources that are currently keeping the event loop alive.

Signed-off-by: Darshan Sen <darshan.sen@postman.com>

PR-URL: https://github.com/nodejs/node/pull/40813
Reviewed-By: Stephen Belanger <admin@stephenbelanger.com>
Reviewed-By: Vladimir de Turckheim <vlad2t@hotmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/process.md                            | 38 ++++++++++++++++
 lib/internal/bootstrap/node.js                | 21 ++++++++-
 lib/internal/timers.js                        | 13 ++++++
 lib/timers.js                                 |  3 ++
 src/node_process_methods.cc                   | 34 ++++++++++++++
 test/parallel/test-handle-wrap-isrefed.js     | 26 +++++++++++
 ...getactiveresources-track-active-handles.js | 44 +++++++++++++++++++
 ...etactiveresources-track-active-requests.js | 11 +++++
 ...activeresources-track-interval-lifetime.js | 21 +++++++++
 ...etactiveresources-track-multiple-timers.js | 20 +++++++++
 ...getactiveresources-track-timer-lifetime.js | 41 +++++++++++++++++
 .../test-process-getactiveresources.js        |  9 ++++
 .../test-net-connect-econnrefused.js          |  5 +--
 13 files changed, 281 insertions(+), 5 deletions(-)
 create mode 100644 test/parallel/test-process-getactiveresources-track-active-handles.js
 create mode 100644 test/parallel/test-process-getactiveresources-track-active-requests.js
 create mode 100644 test/parallel/test-process-getactiveresources-track-interval-lifetime.js
 create mode 100644 test/parallel/test-process-getactiveresources-track-multiple-timers.js
 create mode 100644 test/parallel/test-process-getactiveresources-track-timer-lifetime.js
 create mode 100644 test/parallel/test-process-getactiveresources.js

diff --git a/doc/api/process.md b/doc/api/process.md
index 28db286bd90fd2..d6096325a14b61 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -1817,6 +1817,44 @@ a code.
 Specifying a code to [`process.exit(code)`][`process.exit()`] will override any
 previous setting of `process.exitCode`.
 
+## `process.getActiveResourcesInfo()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+* Returns: {string\[]}
+
+The `process.getActiveResourcesInfo()` method returns an array of strings
+containing the types of the active resources that are currently keeping the
+event loop alive.
+
+```mjs
+import { getActiveResourcesInfo } from 'process';
+import { setTimeout } from 'timers';
+
+console.log('Before:', getActiveResourcesInfo());
+setTimeout(() => {}, 1000);
+console.log('After:', getActiveResourcesInfo());
+// Prints:
+//   Before: [ 'CloseReq', 'TTYWrap', 'TTYWrap', 'TTYWrap' ]
+//   After: [ 'CloseReq', 'TTYWrap', 'TTYWrap', 'TTYWrap', 'Timeout' ]
+```
+
+```cjs
+const { getActiveResourcesInfo } = require('process');
+const { setTimeout } = require('timers');
+
+console.log('Before:', getActiveResourcesInfo());
+setTimeout(() => {}, 1000);
+console.log('After:', getActiveResourcesInfo());
+// Prints:
+//   Before: [ 'TTYWrap', 'TTYWrap', 'TTYWrap' ]
+//   After: [ 'TTYWrap', 'TTYWrap', 'TTYWrap', 'Timeout' ]
+```
+
 ## `process.getegid()`
 
 <!-- YAML
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index b43fb2a5eb4b3a..a6ef700143ee9f 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -39,6 +39,9 @@
 setupPrepareStackTrace();
 
 const {
+  ArrayPrototypeConcat,
+  ArrayPrototypeFilter,
+  ArrayPrototypeMap,
   FunctionPrototypeCall,
   JSONParse,
   ObjectDefineProperty,
@@ -46,12 +49,14 @@ const {
   ObjectGetPrototypeOf,
   ObjectPreventExtensions,
   ObjectSetPrototypeOf,
+  ObjectValues,
   ReflectGet,
   ReflectSet,
   SymbolToStringTag,
   globalThis,
 } = primordials;
 const config = internalBinding('config');
+const internalTimers = require('internal/timers');
 const { deprecate, lazyDOMExceptionClass } = require('internal/util');
 
 setupProcessObject();
@@ -150,6 +155,16 @@ const rawMethods = internalBinding('process_methods');
   process._getActiveRequests = rawMethods._getActiveRequests;
   process._getActiveHandles = rawMethods._getActiveHandles;
 
+  process.getActiveResourcesInfo = function() {
+    return ArrayPrototypeConcat(
+      rawMethods._getActiveRequestsInfo(),
+      rawMethods._getActiveHandlesInfo(),
+      ArrayPrototypeMap(
+        ArrayPrototypeFilter(ObjectValues(internalTimers.activeTimersMap),
+                             ({ resource }) => resource.hasRef()),
+        ({ type }) => type));
+  };
+
   // TODO(joyeecheung): remove these
   process.reallyExit = rawMethods.reallyExit;
   process._kill = rawMethods._kill;
@@ -360,9 +375,11 @@ process.emitWarning = emitWarning;
   // TODO(joyeecheung): either remove it or make it public
   process._tickCallback = runNextTicks;
 
-  const { getTimerCallbacks } = require('internal/timers');
   const { setupTimers } = internalBinding('timers');
-  const { processImmediate, processTimers } = getTimerCallbacks(runNextTicks);
+  const {
+    processImmediate,
+    processTimers,
+  } = internalTimers.getTimerCallbacks(runNextTicks);
   // Sets two per-Environment callbacks that will be run from libuv:
   // - processImmediate will be run in the callback of the per-Environment
   //   check handle.
diff --git a/lib/internal/timers.js b/lib/internal/timers.js
index 9a07fe3348f65e..8edff995326a01 100644
--- a/lib/internal/timers.js
+++ b/lib/internal/timers.js
@@ -139,6 +139,12 @@ const kRefed = Symbol('refed');
 // Create a single linked list instance only once at startup
 const immediateQueue = new ImmediateList();
 
+// Object map containing timers
+//
+// - key = asyncId
+// - value = { type, resource }
+const activeTimersMap = ObjectCreate(null);
+
 let nextExpiry = Infinity;
 let refCount = 0;
 
@@ -160,6 +166,7 @@ function initAsyncResource(resource, type) {
     resource[trigger_async_id_symbol] = getDefaultTriggerAsyncId();
   if (initHooksExist())
     emitInit(asyncId, type, triggerAsyncId, resource);
+  activeTimersMap[asyncId] = { type, resource };
 }
 
 // Timer constructor function.
@@ -446,6 +453,8 @@ function getTimerCallbacks(runNextTicks) {
         continue;
       }
 
+      // TODO(RaisinTen): Destroy and unref the Immediate after _onImmediate()
+      // gets executed, just like how Timeouts work.
       immediate._destroyed = true;
 
       immediateInfo[kCount]--;
@@ -469,6 +478,7 @@ function getTimerCallbacks(runNextTicks) {
 
         if (destroyHooksExist())
           emitDestroy(asyncId);
+        delete activeTimersMap[asyncId];
 
         outstandingQueue.head = immediate = immediate._idleNext;
       }
@@ -541,6 +551,7 @@ function getTimerCallbacks(runNextTicks) {
 
           if (destroyHooksExist())
             emitDestroy(asyncId);
+          delete activeTimersMap[asyncId];
         }
         continue;
       }
@@ -569,6 +580,7 @@ function getTimerCallbacks(runNextTicks) {
 
           if (destroyHooksExist())
             emitDestroy(asyncId);
+          delete activeTimersMap[asyncId];
         }
       }
 
@@ -658,6 +670,7 @@ module.exports = {
   active,
   unrefActive,
   insert,
+  activeTimersMap,
   timerListMap,
   timerListQueue,
   decRefCount,
diff --git a/lib/timers.js b/lib/timers.js
index a4543fea1df6bc..51e8e69d172022 100644
--- a/lib/timers.js
+++ b/lib/timers.js
@@ -45,6 +45,7 @@ const {
   kRefed,
   kHasPrimitive,
   getTimerDuration,
+  activeTimersMap,
   timerListMap,
   timerListQueue,
   immediateQueue,
@@ -87,6 +88,7 @@ function unenroll(item) {
   // Fewer checks may be possible, but these cover everything.
   if (destroyHooksExist() && item[async_id_symbol] !== undefined)
     emitDestroy(item[async_id_symbol]);
+  delete activeTimersMap[item[async_id_symbol]];
 
   L.remove(item);
 
@@ -329,6 +331,7 @@ function clearImmediate(immediate) {
   if (destroyHooksExist() && immediate[async_id_symbol] !== undefined) {
     emitDestroy(immediate[async_id_symbol]);
   }
+  delete activeTimersMap[immediate[async_id_symbol]];
 
   immediate._onImmediate = null;
 
diff --git a/src/node_process_methods.cc b/src/node_process_methods.cc
index e4b16805586cb9..bc5d41382f20f1 100644
--- a/src/node_process_methods.cc
+++ b/src/node_process_methods.cc
@@ -1,3 +1,4 @@
+#include "async_wrap-inl.h"
 #include "base_object-inl.h"
 #include "debug_utils-inl.h"
 #include "env-inl.h"
@@ -257,6 +258,21 @@ static void GetActiveRequests(const FunctionCallbackInfo<Value>& args) {
       Array::New(env->isolate(), request_v.data(), request_v.size()));
 }
 
+static void GetActiveRequestsInfo(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  std::vector<Local<Value>> requests_info;
+  for (ReqWrapBase* req_wrap : *env->req_wrap_queue()) {
+    AsyncWrap* w = req_wrap->GetAsyncWrap();
+    if (w->persistent().IsEmpty()) continue;
+    requests_info.emplace_back(OneByteString(env->isolate(),
+                               w->MemoryInfoName().c_str()));
+  }
+
+  args.GetReturnValue().Set(
+      Array::New(env->isolate(), requests_info.data(), requests_info.size()));
+}
+
 // Non-static, friend of HandleWrap. Could have been a HandleWrap method but
 // implemented here for consistency with GetActiveRequests().
 void GetActiveHandles(const FunctionCallbackInfo<Value>& args) {
@@ -272,6 +288,20 @@ void GetActiveHandles(const FunctionCallbackInfo<Value>& args) {
       Array::New(env->isolate(), handle_v.data(), handle_v.size()));
 }
 
+void GetActiveHandlesInfo(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+
+  std::vector<Local<Value>> handles_info;
+  for (HandleWrap* w : *env->handle_wrap_queue()) {
+    if (w->persistent().IsEmpty() || !HandleWrap::HasRef(w)) continue;
+    handles_info.emplace_back(OneByteString(env->isolate(),
+                              w->MemoryInfoName().c_str()));
+  }
+
+  args.GetReturnValue().Set(
+      Array::New(env->isolate(), handles_info.data(), handles_info.size()));
+}
+
 static void ResourceUsage(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
@@ -547,7 +577,9 @@ static void Initialize(Local<Object> target,
   env->SetMethod(target, "resourceUsage", ResourceUsage);
 
   env->SetMethod(target, "_getActiveRequests", GetActiveRequests);
+  env->SetMethod(target, "_getActiveRequestsInfo", GetActiveRequestsInfo);
   env->SetMethod(target, "_getActiveHandles", GetActiveHandles);
+  env->SetMethod(target, "_getActiveHandlesInfo", GetActiveHandlesInfo);
   env->SetMethod(target, "_kill", Kill);
 
   env->SetMethodNoSideEffect(target, "cwd", Cwd);
@@ -574,7 +606,9 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(ResourceUsage);
 
   registry->Register(GetActiveRequests);
+  registry->Register(GetActiveRequestsInfo);
   registry->Register(GetActiveHandles);
+  registry->Register(GetActiveHandlesInfo);
   registry->Register(Kill);
 
   registry->Register(Cwd);
diff --git a/test/parallel/test-handle-wrap-isrefed.js b/test/parallel/test-handle-wrap-isrefed.js
index 2fb766ce72ea4b..d4ca0070929721 100644
--- a/test/parallel/test-handle-wrap-isrefed.js
+++ b/test/parallel/test-handle-wrap-isrefed.js
@@ -106,5 +106,31 @@ const { kStateSymbol } = require('internal/dgram');
                 false, 'tcp_wrap: not unrefed on close')));
 }
 
+// timers
+{
+  strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Timeout').length, 0);
+  const timeout = setTimeout(() => {}, 500);
+  strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Timeout').length, 1);
+  timeout.unref();
+  strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Timeout').length, 0);
+  timeout.ref();
+  strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Timeout').length, 1);
+
+  strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Immediate').length, 0);
+  const immediate = setImmediate(() => {});
+  strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Immediate').length, 1);
+  immediate.unref();
+  strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Immediate').length, 0);
+  immediate.ref();
+  strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Immediate').length, 1);
+}
 
 // See also test/pseudo-tty/test-handle-wrap-isrefed-tty.js
diff --git a/test/parallel/test-process-getactiveresources-track-active-handles.js b/test/parallel/test-process-getactiveresources-track-active-handles.js
new file mode 100644
index 00000000000000..25a40bc64a102c
--- /dev/null
+++ b/test/parallel/test-process-getactiveresources-track-active-handles.js
@@ -0,0 +1,44 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const net = require('net');
+const NUM = 8;
+const connections = [];
+const clients = [];
+let clients_counter = 0;
+
+const server = net.createServer(function listener(c) {
+  connections.push(c);
+}).listen(0, makeConnection);
+
+
+function makeConnection() {
+  if (clients_counter >= NUM) return;
+  net.connect(server.address().port, function connected() {
+    clientConnected(this);
+    makeConnection();
+  });
+}
+
+
+function clientConnected(client) {
+  clients.push(client);
+  if (++clients_counter >= NUM)
+    checkAll();
+}
+
+
+function checkAll() {
+  assert.strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'TCPSocketWrap').length,
+                     clients.length + connections.length);
+
+  clients.forEach((item) => item.destroy());
+  connections.forEach((item) => item.end());
+
+  assert.strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'TCPServerWrap').length, 1);
+
+  server.close();
+}
diff --git a/test/parallel/test-process-getactiveresources-track-active-requests.js b/test/parallel/test-process-getactiveresources-track-active-requests.js
new file mode 100644
index 00000000000000..12957ff956fd4d
--- /dev/null
+++ b/test/parallel/test-process-getactiveresources-track-active-requests.js
@@ -0,0 +1,11 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+
+for (let i = 0; i < 12; i++) {
+  fs.open(__filename, 'r', common.mustCall());
+}
+
+assert.strictEqual(process.getActiveResourcesInfo().length, 12);
diff --git a/test/parallel/test-process-getactiveresources-track-interval-lifetime.js b/test/parallel/test-process-getactiveresources-track-interval-lifetime.js
new file mode 100644
index 00000000000000..1563673041abe4
--- /dev/null
+++ b/test/parallel/test-process-getactiveresources-track-interval-lifetime.js
@@ -0,0 +1,21 @@
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+
+assert.strictEqual(process.getActiveResourcesInfo().filter(
+  (type) => type === 'Timeout').length, 0);
+
+let count = 0;
+const interval = setInterval(common.mustCall(() => {
+  assert.strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Timeout').length, 1);
+  ++count;
+  if (count === 3) {
+    clearInterval(interval);
+  }
+}, 3), 0);
+
+assert.strictEqual(process.getActiveResourcesInfo().filter(
+  (type) => type === 'Timeout').length, 1);
diff --git a/test/parallel/test-process-getactiveresources-track-multiple-timers.js b/test/parallel/test-process-getactiveresources-track-multiple-timers.js
new file mode 100644
index 00000000000000..8022566882d5de
--- /dev/null
+++ b/test/parallel/test-process-getactiveresources-track-multiple-timers.js
@@ -0,0 +1,20 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+for (let i = 0; i < 10; ++i) {
+  for (let j = 0; j < 10; ++j) {
+    setTimeout(common.mustCall(), i);
+  }
+}
+
+assert.strictEqual(process.getActiveResourcesInfo().filter(
+  (type) => type === 'Timeout').length, 100);
+
+for (let i = 0; i < 10; ++i) {
+  setImmediate(common.mustCall());
+}
+
+assert.strictEqual(process.getActiveResourcesInfo().filter(
+  (type) => type === 'Immediate').length, 10);
diff --git a/test/parallel/test-process-getactiveresources-track-timer-lifetime.js b/test/parallel/test-process-getactiveresources-track-timer-lifetime.js
new file mode 100644
index 00000000000000..72a830a1640c36
--- /dev/null
+++ b/test/parallel/test-process-getactiveresources-track-timer-lifetime.js
@@ -0,0 +1,41 @@
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+
+{
+  assert.strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Timeout').length, 0);
+
+  const timeout = setTimeout(common.mustCall(() => {
+    assert.strictEqual(process.getActiveResourcesInfo().filter(
+      (type) => type === 'Timeout').length, 1);
+    clearTimeout(timeout);
+    assert.strictEqual(process.getActiveResourcesInfo().filter(
+      (type) => type === 'Timeout').length, 0);
+  }), 0);
+
+  assert.strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Timeout').length, 1);
+}
+
+{
+  assert.strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Immediate').length, 0);
+
+  const immediate = setImmediate(common.mustCall(() => {
+    // TODO(RaisinTen): Change this test to the following when the Immediate is
+    // destroyed and unrefed after the callback gets executed.
+    // assert.strictEqual(process.getActiveResourcesInfo().filter(
+    //   (type) => type === 'Immediate').length, 1);
+    assert.strictEqual(process.getActiveResourcesInfo().filter(
+      (type) => type === 'Immediate').length, 0);
+    clearImmediate(immediate);
+    assert.strictEqual(process.getActiveResourcesInfo().filter(
+      (type) => type === 'Immediate').length, 0);
+  }));
+
+  assert.strictEqual(process.getActiveResourcesInfo().filter(
+    (type) => type === 'Immediate').length, 1);
+}
diff --git a/test/parallel/test-process-getactiveresources.js b/test/parallel/test-process-getactiveresources.js
new file mode 100644
index 00000000000000..a2df7d580d15ea
--- /dev/null
+++ b/test/parallel/test-process-getactiveresources.js
@@ -0,0 +1,9 @@
+'use strict';
+
+require('../common');
+
+const assert = require('assert');
+
+setTimeout(() => {}, 0);
+
+assert.deepStrictEqual(process.getActiveResourcesInfo(), ['Timeout']);
diff --git a/test/sequential/test-net-connect-econnrefused.js b/test/sequential/test-net-connect-econnrefused.js
index 4fd4f8b6943e3c..7dec16d2326dd1 100644
--- a/test/sequential/test-net-connect-econnrefused.js
+++ b/test/sequential/test-net-connect-econnrefused.js
@@ -54,9 +54,8 @@ function pummel() {
 
 function check() {
   setTimeout(common.mustCall(function() {
-    assert.strictEqual(process._getActiveRequests().length, 0);
-    const activeHandles = process._getActiveHandles();
-    assert.ok(activeHandles.every((val) => val.constructor.name !== 'Socket'));
+    assert.strictEqual(process.getActiveResourcesInfo().filter(
+      (type) => type === 'TCPWRAP').length, 0);
   }), 0);
 }