Add ANR features

Author: timfish

index.d.ts

@@ -1,5 +1,5 @@
 
-export declare function registerThread(): void;
+export declare function registerThread(name?: string): void;
 
 export type StackFrame = {
     function: string;
@@ -8,8 +8,8 @@ export type StackFrame = {
     colno: number;
 };
 
-export type Trace = {
-    main: StackFrame[];
-} & Record<string, StackFrame[]>;
+export type Trace = Record<string, StackFrame[]>;
 
-export declare function captureStackTrace(excludeWorkers: boolean): Trace;
+export declare function captureStackTrace(excludeWorkers: boolean): Trace;
+
+export declare function getThreadLastSeen(): Record<string, number>;

index.js

@@ -1,9 +1,12 @@
-const { isMainThread, threadId } = require('node:worker_threads');
+const { threadId } = require('node:worker_threads');
 const native = require('./build/release/cross-thread-stack-trace.node');
 
-exports.registerThread = function () {
-    native.registerThread(isMainThread ? -1 : threadId );
+exports.registerThread = function (name = String(threadId)) {
+    native.registerThread(name);
 };
 exports.captureStackTrace = function () {
     return native.captureStackTrace();
+};
+exports.getThreadLastSeen = function () {
+    return native.getThreadLastSeen();
 };

module.cc

@@ -1,15 +1,28 @@
 #include <node.h>
 #include <mutex>
 #include <future>
+#include <chrono>
 
 using namespace v8;
 using namespace node;
+using namespace std::chrono;
 
 static const int kMaxStackFrames = 255;
 
+// Structure to hold information for each thread/isolate
+struct ThreadInfo
+{
+    // Thread name
+    std::string thread_name;
+    // Last time this thread was seen in milliseconds since epoch
+    milliseconds last_seen;
+};
+
 static std::mutex threads_mutex;
-static std::unordered_map<v8::Isolate *, int> threads = {};
+// Map to hold all registered threads and their information
+static std::unordered_map<v8::Isolate *, ThreadInfo> threads = {};
 
+// Function to be called when an isolate's execution is interrupted
 static void ExecutionInterrupted(Isolate *isolate, void *data)
 {
     auto promise = static_cast<std::promise<Local<Array>> *>(data);
@@ -68,32 +81,38 @@ static void ExecutionInterrupted(Isolate *isolate, void *data)
     promise->set_value(frames);
 }
 
+// Function to capture the stack trace of a single isolate
 Local<Array> CaptureStackTrace(Isolate *isolate)
 {
     std::promise<Local<Array>> promise;
     auto future = promise.get_future();
 
+    // The v8 isolate must be interrupted to capture the stack trace
+    // Execution resumes automatically after ExecutionInterrupted returns
     isolate->RequestInterrupt(ExecutionInterrupted, &promise);
     return future.get();
 }
 
+// Function to capture stack traces from all registered threads
 void CaptureStackTraces(const FunctionCallbackInfo<Value> &args)
 {
     auto capture_from_isolate = args.GetIsolate();
 
     using ThreadResult = std::tuple<std::string, Local<Array>>;
     std::vector<std::future<ThreadResult>> futures;
 
+    // We collect the futures into a vec so they can be processed in parallel
     std::lock_guard<std::mutex> lock(threads_mutex);
-    for (auto [thread_isolate, thread_id] : threads)
+    for (auto [thread_isolate, thread_info] : threads)
     {
         if (thread_isolate == capture_from_isolate)
             continue;
-        auto thread_name = thread_id == -1 ? "main" : "worker-" + std::to_string(thread_id);
+        auto thread_name = thread_info.thread_name;
         futures.emplace_back(std::async(std::launch::async, [thread_name](Isolate *isolate) -> ThreadResult
                                         { return std::make_tuple(thread_name, CaptureStackTrace(isolate)); }, thread_isolate));
     }
 
+    // We wait for all futures to complete and collect their results into a JavaScript object
     Local<Object> result = Object::New(capture_from_isolate);
     for (auto &future : futures)
     {
@@ -105,30 +124,67 @@ void CaptureStackTraces(const FunctionCallbackInfo<Value> &args)
     args.GetReturnValue().Set(result);
 }
 
+// Cleanup function to remove the thread from the map when the isolate is destroyed
 void Cleanup(void *arg)
 {
     auto isolate = static_cast<Isolate *>(arg);
     std::lock_guard<std::mutex> lock(threads_mutex);
     threads.erase(isolate);
 }
 
+// Function to register a thread and update it's last seen time
 void RegisterThread(const FunctionCallbackInfo<Value> &args)
 {
     auto isolate = args.GetIsolate();
 
-    if (args.Length() != 1 || !args[0]->IsNumber())
+    if (args.Length() != 1 || !args[0]->IsString())
     {
-        isolate->ThrowException(Exception::Error(String::NewFromUtf8(isolate, "registerThread() requires a single threadId argument", NewStringType::kInternalized).ToLocalChecked()));
+        isolate->ThrowException(Exception::Error(String::NewFromUtf8(isolate, "registerThread(name) requires a single name argument", NewStringType::kInternalized).ToLocalChecked()));
         return;
     }
 
-    auto thread_id = args[0].As<Number>()->Value();
+    v8::String::Utf8Value utf8(isolate, args[0]);
+    std::string thread_name(*utf8 ? *utf8 : "");
+
+    {
+        std::lock_guard<std::mutex> lock(threads_mutex);
+        auto found = threads.find(isolate);
+        if (found == threads.end())
+        {
+            threads.emplace(isolate, ThreadInfo{thread_name, milliseconds::zero()});
+            // Register a cleanup hook to remove this thread when the isolate is destroyed
+            node::AddEnvironmentCleanupHook(isolate, Cleanup, isolate);
+        }
+        else
+        {
+            auto &thread_info = found->second;
+            thread_info.thread_name = thread_name;
+            thread_info.last_seen = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
+        }
+    }
+}
 
+// Function to get the last seen time of all registered threads
+void GetThreadLastSeen(const FunctionCallbackInfo<Value> &args)
+{
+    Isolate *isolate = args.GetIsolate();
+    Local<Object> result = Object::New(isolate);
+    milliseconds now = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
     {
         std::lock_guard<std::mutex> lock(threads_mutex);
-        threads.emplace(isolate, thread_id);
+        for (const auto &[thread_isolate, info] : threads)
+        {
+            if (info.last_seen == milliseconds::zero())
+                continue; // Skip threads that have not registered more than once
+
+            int64_t ms_since = (now - info.last_seen).count();
+            result->Set(isolate->GetCurrentContext(),
+                        String::NewFromUtf8(isolate, info.thread_name.c_str(), NewStringType::kNormal).ToLocalChecked(),
+                        Number::New(isolate, ms_since))
+                .Check();
+        }
     }
-    node::AddEnvironmentCleanupHook(isolate, Cleanup, isolate);
+    args.GetReturnValue().Set(result);
 }
 
 extern "C" NODE_MODULE_EXPORT void NODE_MODULE_INITIALIZER(Local<Object> exports,
@@ -146,4 +202,9 @@ extern "C" NODE_MODULE_EXPORT void NODE_MODULE_INITIALIZER(Local<Object> exports
                  String::NewFromUtf8(isolate, "registerThread", NewStringType::kInternalized).ToLocalChecked(),
                  FunctionTemplate::New(isolate, RegisterThread)->GetFunction(context).ToLocalChecked())
         .Check();
+
+    exports->Set(context,
+                 String::NewFromUtf8(isolate, "getThreadLastSeen", NewStringType::kInternalized).ToLocalChecked(),
+                 FunctionTemplate::New(isolate, GetThreadLastSeen)->GetFunction(context).ToLocalChecked())
+        .Check();
 }

test/basic.test.js

@@ -12,7 +12,7 @@ describe("Basic", () => {
 
         const stacks = JSON.parse(result.stdout.toString());
 
-        expect(stacks.main).toEqual(expect.arrayContaining([
+        expect(stacks["0"]).toEqual(expect.arrayContaining([
             {
                 function: 'pbkdf2Sync',
                 filename: expect.any(String),
@@ -33,7 +33,7 @@ describe("Basic", () => {
             },
         ]));
 
-        expect(stacks['worker-2']).toEqual(expect.arrayContaining([
+        expect(stacks['2']).toEqual(expect.arrayContaining([
             {
                 function: 'pbkdf2Sync',
                 filename: expect.any(String),