diff --git a/doc/api/process.md b/doc/api/process.md
index 28db286bd90fd2..5d042977f96307 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -1817,6 +1817,71 @@ 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: {Array} of objects containing the `type`, `asyncId` and the
+  `triggerAsyncId` of the currently active requests, handles and timers.
+
+The `process.getActiveResourcesInfo()` method can be called at any moment and it
+would return an array of objects containing some information about all the
+resources that are currently keeping the event loop alive. This can be useful
+while debugging.
+
+The same functionality can be implemented using [`async_hooks`][] by setting up
+an [`AsyncHook`][] that keeps a track of the calls made to [`init` callbacks][]
+and [`destroy` callbacks][] but this function should be preferred because it
+doesn't incur the overhead of creating any [`AsyncHook`][].
+
+```mjs
+import { getActiveResourcesInfo } from 'process';
+import { setTimeout } from 'timers';
+
+console.log('Before:', getActiveResourcesInfo());
+setTimeout(() => {}, 1000);
+console.log('After:', getActiveResourcesInfo());
+// Prints:
+//   Before: [
+//     { type: 'CloseReq', asyncId: 6, triggerAsyncId: 0 },
+//     { type: 'TTYWrap', asyncId: 7, triggerAsyncId: 0 },
+//     { type: 'TTYWrap', asyncId: 9, triggerAsyncId: 0 },
+//     { type: 'TTYWrap', asyncId: 10, triggerAsyncId: 0 }
+//   ]
+//   After: [
+//     { type: 'CloseReq', asyncId: 6, triggerAsyncId: 0 },
+//     { type: 'TTYWrap', asyncId: 7, triggerAsyncId: 0 },
+//     { type: 'TTYWrap', asyncId: 9, triggerAsyncId: 0 },
+//     { type: 'TTYWrap', asyncId: 10, triggerAsyncId: 0 },
+//     { type: 'Timeout', asyncId: 12, triggerAsyncId: 0 }
+//   ]
+```
+
+```cjs
+const { getActiveResourcesInfo } = require('process');
+const { setTimeout } = require('timers');
+
+console.log('Before:', getActiveResourcesInfo());
+setTimeout(() => {}, 1000);
+console.log('After:', getActiveResourcesInfo());
+// Prints:
+//   Before: [
+//     { type: 'TTYWrap', asyncId: 2, triggerAsyncId: 1 },
+//     { type: 'TTYWrap', asyncId: 4, triggerAsyncId: 1 },
+//     { type: 'TTYWrap', asyncId: 5, triggerAsyncId: 1 }
+//   ]
+//   After: [
+//     { type: 'TTYWrap', asyncId: 2, triggerAsyncId: 1 },
+//     { type: 'TTYWrap', asyncId: 4, triggerAsyncId: 1 },
+//     { type: 'TTYWrap', asyncId: 5, triggerAsyncId: 1 },
+//     { type: 'Timeout', asyncId: 7, triggerAsyncId: 1 }
+//   ]
+```
+
 ## `process.getegid()`
 
 <!-- YAML
@@ -3792,6 +3857,7 @@ cases:
 [`'message'`]: child_process.md#event-message
 [`'uncaughtException'`]: #event-uncaughtexception
 [`--unhandled-rejections`]: cli.md#--unhandled-rejectionsmode
+[`AsyncHook`]: async_hooks.md#class-asynchook
 [`Buffer`]: buffer.md
 [`ChildProcess.disconnect()`]: child_process.md#subprocessdisconnect
 [`ChildProcess.send()`]: child_process.md#subprocesssendmessage-sendhandle-options-callback
@@ -3802,9 +3868,12 @@ cases:
 [`Promise.race()`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race
 [`Worker`]: worker_threads.md#class-worker
 [`Worker` constructor]: worker_threads.md#new-workerfilename-options
+[`async_hooks`]: async_hooks.md
 [`console.error()`]: console.md#consoleerrordata-args
 [`console.log()`]: console.md#consolelogdata-args
+[`destroy` callbacks]: async_hooks.md#destroyasyncid
 [`domain`]: domain.md
+[`init` callbacks]: async_hooks.md#initasyncid-type-triggerasyncid-resource
 [`net.Server`]: net.md#class-netserver
 [`net.Socket`]: net.md#class-netsocket
 [`os.constants.dlopen`]: os.md#dlopen-constants
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index b43fb2a5eb4b3a..6b6de928b89418 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -39,6 +39,9 @@
 setupPrepareStackTrace();
 
 const {
+  ArrayPrototypeConcat,
+  ArrayPrototypeForEach,
+  ArrayPrototypePush,
   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,37 @@ const rawMethods = internalBinding('process_methods');
   process._getActiveRequests = rawMethods._getActiveRequests;
   process._getActiveHandles = rawMethods._getActiveHandles;
 
+  process.getActiveResourcesInfo = function() {
+    const resources = ArrayPrototypeConcat(rawMethods._getActiveRequestsInfo(),
+                                           rawMethods._getActiveHandlesInfo());
+
+    ArrayPrototypeForEach(ObjectValues(internalTimers.timerListMap), (list) => {
+      let timeout = list._idlePrev === list ? null : list._idlePrev;
+      while (timeout !== null) {
+        ArrayPrototypePush(resources, {
+          type: 'Timeout',
+          asyncId: timeout[internalTimers.async_id_symbol],
+          triggerAsyncId: timeout[internalTimers.trigger_async_id_symbol],
+        });
+        timeout = timeout._idlePrev === list ? null : list._idlePrev;
+      }
+    });
+
+    const queue = internalTimers.outstandingQueue.head !== null ?
+      internalTimers.outstandingQueue : internalTimers.immediateQueue;
+    let immediate = queue.head;
+    while (immediate !== null) {
+      ArrayPrototypePush(resources, {
+        type: 'Immediate',
+        asyncId: immediate[internalTimers.async_id_symbol],
+        triggerAsyncId: immediate[internalTimers.trigger_async_id_symbol],
+      });
+      immediate = immediate._idleNext;
+    }
+
+    return resources;
+  };
+
   // TODO(joyeecheung): remove these
   process.reallyExit = rawMethods.reallyExit;
   process._kill = rawMethods._kill;
@@ -360,9 +396,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..9aa572989c8cd1 100644
--- a/lib/internal/timers.js
+++ b/lib/internal/timers.js
@@ -139,6 +139,11 @@ const kRefed = Symbol('refed');
 // 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;
 
@@ -413,11 +418,6 @@ function setPosition(node, pos) {
 }
 
 function getTimerCallbacks(runNextTicks) {
-  // 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();
-
   function processImmediate() {
     const queue = outstandingQueue.head !== null ?
       outstandingQueue : immediateQueue;
@@ -649,6 +649,7 @@ module.exports = {
   setUnrefTimeout,
   getTimerDuration,
   immediateQueue,
+  outstandingQueue,
   getTimerCallbacks,
   immediateInfoFields: {
     kCount,
diff --git a/src/node_process_methods.cc b/src/node_process_methods.cc
index e4b16805586cb9..5afcf9df3075d0 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"
@@ -43,8 +44,11 @@ using v8::FunctionCallbackInfo;
 using v8::HeapStatistics;
 using v8::Integer;
 using v8::Isolate;
+using v8::JustVoid;
 using v8::Local;
+using v8::Maybe;
 using v8::NewStringType;
+using v8::Nothing;
 using v8::Number;
 using v8::Object;
 using v8::String;
@@ -242,6 +246,28 @@ static void Uptime(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(result);
 }
 
+static Maybe<void> GetResourceInfo(Environment* env, AsyncWrap* w,
+                                   std::vector<Local<Value>>* resources) {
+  Local<Object> resource = Object::New(env->isolate());
+
+  if (resource->Set(env->context(),
+                    OneByteString(env->isolate(), "type"),
+                    OneByteString(env->isolate(), w->MemoryInfoName().c_str()))
+                        .IsNothing() ||
+      resource->Set(env->context(),
+                    OneByteString(env->isolate(), "asyncId"),
+                    Number::New(env->isolate(), w->get_async_id()))
+                        .IsNothing() ||
+      resource->Set(env->context(),
+                    OneByteString(env->isolate(), "triggerAsyncId"),
+                    Number::New(env->isolate(), w->get_trigger_async_id()))
+                        .IsNothing()) return Nothing<void>();
+
+  resources->emplace_back(resource);
+
+  return JustVoid();
+}
+
 static void GetActiveRequests(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
@@ -257,6 +283,20 @@ 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;
+  for (ReqWrapBase* req_wrap : *env->req_wrap_queue()) {
+    AsyncWrap* w = req_wrap->GetAsyncWrap();
+    if (!w->persistent().IsEmpty())
+      if (GetResourceInfo(env, w, &requests).IsNothing()) return;
+  }
+
+  args.GetReturnValue().Set(
+      Array::New(env->isolate(), requests.data(), requests.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 +312,19 @@ 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;
+  for (HandleWrap* w : *env->handle_wrap_queue()) {
+    if (!w->persistent().IsEmpty() && HandleWrap::HasRef(w))
+      if (GetResourceInfo(env, w, &handles).IsNothing()) return;
+  }
+
+  args.GetReturnValue().Set(
+      Array::New(env->isolate(), handles.data(), handles.size()));
+}
+
 static void ResourceUsage(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
 
@@ -547,7 +600,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 +629,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);