Have a config option for collecting async IDs

szegedi · szegedi · commit 79992a0021f4 · 2025-03-06T14:39:16.000+01:00
diff --git a/bindings/profilers/wall.cc b/bindings/profilers/wall.cc
@@ -474,11 +474,13 @@ std::shared_ptr<ContextsByNode> WallProfiler::GetContextsByNode(
                         sampleContext.context.get()->Get(isolate))
                   .Check();
             }
-            timedContext
-                ->Set(v8Context,
-                      asyncIdKey,
-                      NewNumberFromInt64(isolate, sampleContext.async_id))
-                .Check();
+            if (collectAsyncId_) {
+              timedContext
+                  ->Set(v8Context,
+                        asyncIdKey,
+                        NewNumberFromInt64(isolate, sampleContext.async_id))
+                  .Check();
+            }
           }
         }
         array->Set(v8Context, array->Length(), timedContext).Check();
@@ -513,6 +515,7 @@ WallProfiler::WallProfiler(std::chrono::microseconds samplingPeriod,
                            bool withContexts,
                            bool workaroundV8Bug,
                            bool collectCpuTime,
+                           bool collectAsyncId,
                            bool isMainThread)
     : samplingPeriod_(samplingPeriod),
       includeLines_(includeLines),
@@ -524,6 +527,7 @@ WallProfiler::WallProfiler(std::chrono::microseconds samplingPeriod,
   // event just after triggers the issue.
   workaroundV8Bug_ = workaroundV8Bug && DD_WALL_USE_SIGPROF && detectV8Bug_;
   collectCpuTime_ = collectCpuTime && withContexts;
+  collectAsyncId_ = collectAsyncId && withContexts;
 
   if (withContexts_) {
     contexts_.reserve(duration * 2 / samplingPeriod);
@@ -544,8 +548,10 @@ WallProfiler::WallProfiler(std::chrono::microseconds samplingPeriod,
   jsArray_ = v8::Global<v8::Uint32Array>(isolate, jsArray);
   std::fill(fields_, fields_ + kFieldCount, 0);
 
-  isolate->AddGCPrologueCallback(&GCPrologueCallback, this);
-  isolate->AddGCEpilogueCallback(&GCEpilogueCallback, this);
+  if (collectAsyncId_) {
+    isolate->AddGCPrologueCallback(&GCPrologueCallback, this);
+    isolate->AddGCEpilogueCallback(&GCEpilogueCallback, this);
+  }
 }
 
 WallProfiler::~WallProfiler() {
@@ -559,13 +565,21 @@ void WallProfiler::Dispose(Isolate* isolate) {
 
     g_profilers.RemoveProfiler(isolate, this);
 
-    if (isolate != nullptr) {
+    if (isolate != nullptr && collectAsyncId_) {
       isolate->RemoveGCPrologueCallback(&GCPrologueCallback, this);
       isolate->RemoveGCEpilogueCallback(&GCEpilogueCallback, this);
     }
   }
 }
 
+#define DD_WALL_PROFILER_GET_BOOLEAN_CONFIG(name)                              \
+  auto name##Value =                                                           \
+      Nan::Get(arg, Nan::New<v8::String>(#name).ToLocalChecked());             \
+  if (name##Value.IsEmpty() || !name##Value.ToLocalChecked()->IsBoolean()) {   \
+    return Nan::ThrowTypeError(#name " must be a boolean.");                   \
+  }                                                                            \
+  bool name = name##Value.ToLocalChecked().As<v8::Boolean>()->Value();
+
 NAN_METHOD(WallProfiler::New) {
   if (info.Length() != 1 || !info[0]->IsObject()) {
     return Nan::ThrowTypeError("WallProfiler must have one object argument.");
@@ -604,50 +618,12 @@ NAN_METHOD(WallProfiler::New) {
       return Nan::ThrowTypeError("Duration must not be less than sample rate.");
     }
 
-    auto lineNumbersValue =
-        Nan::Get(arg, Nan::New<v8::String>("lineNumbers").ToLocalChecked());
-    if (lineNumbersValue.IsEmpty() ||
-        !lineNumbersValue.ToLocalChecked()->IsBoolean()) {
-      return Nan::ThrowTypeError("lineNumbers must be a boolean.");
-    }
-    bool lineNumbers =
-        lineNumbersValue.ToLocalChecked().As<v8::Boolean>()->Value();
-
-    auto withContextsValue =
-        Nan::Get(arg, Nan::New<v8::String>("withContexts").ToLocalChecked());
-    if (withContextsValue.IsEmpty() ||
-        !withContextsValue.ToLocalChecked()->IsBoolean()) {
-      return Nan::ThrowTypeError("withContext must be a boolean.");
-    }
-    bool withContexts =
-        withContextsValue.ToLocalChecked().As<v8::Boolean>()->Value();
-
-    auto workaroundV8BugValue =
-        Nan::Get(arg, Nan::New<v8::String>("workaroundV8Bug").ToLocalChecked());
-    if (workaroundV8BugValue.IsEmpty() ||
-        !workaroundV8BugValue.ToLocalChecked()->IsBoolean()) {
-      return Nan::ThrowTypeError("workaroundV8Bug must be a boolean.");
-    }
-    bool workaroundV8Bug =
-        workaroundV8BugValue.ToLocalChecked().As<v8::Boolean>()->Value();
-
-    auto collectCpuTimeValue =
-        Nan::Get(arg, Nan::New<v8::String>("collectCpuTime").ToLocalChecked());
-    if (collectCpuTimeValue.IsEmpty() ||
-        !collectCpuTimeValue.ToLocalChecked()->IsBoolean()) {
-      return Nan::ThrowTypeError("collectCpuTime must be a boolean.");
-    }
-    bool collectCpuTime =
-        collectCpuTimeValue.ToLocalChecked().As<v8::Boolean>()->Value();
-
-    auto isMainThreadValue =
-        Nan::Get(arg, Nan::New<v8::String>("isMainThread").ToLocalChecked());
-    if (isMainThreadValue.IsEmpty() ||
-        !isMainThreadValue.ToLocalChecked()->IsBoolean()) {
-      return Nan::ThrowTypeError("isMainThread must be a boolean.");
-    }
-    bool isMainThread =
-        isMainThreadValue.ToLocalChecked().As<v8::Boolean>()->Value();
+    DD_WALL_PROFILER_GET_BOOLEAN_CONFIG(lineNumbers);
+    DD_WALL_PROFILER_GET_BOOLEAN_CONFIG(withContexts);
+    DD_WALL_PROFILER_GET_BOOLEAN_CONFIG(workaroundV8Bug);
+    DD_WALL_PROFILER_GET_BOOLEAN_CONFIG(collectCpuTime);
+    DD_WALL_PROFILER_GET_BOOLEAN_CONFIG(collectAsyncId);
+    DD_WALL_PROFILER_GET_BOOLEAN_CONFIG(isMainThread);
 
     if (withContexts && !DD_WALL_USE_SIGPROF) {
       return Nan::ThrowTypeError("Contexts are not supported.");
@@ -657,6 +633,10 @@ NAN_METHOD(WallProfiler::New) {
       return Nan::ThrowTypeError("Cpu time collection requires contexts.");
     }
 
+    if (collectAsyncId && !withContexts) {
+      return Nan::ThrowTypeError("Async ID collection requires contexts.");
+    }
+
     if (lineNumbers && withContexts) {
       // Currently custom contexts are not compatible with caller line
       // information, because it's not possible to associate context with line
@@ -682,6 +662,7 @@ NAN_METHOD(WallProfiler::New) {
                                          withContexts,
                                          workaroundV8Bug,
                                          collectCpuTime,
+                                         collectAsyncId,
                                          isMainThread);
     obj->Wrap(info.This());
     info.GetReturnValue().Set(info.This());
@@ -693,6 +674,8 @@ NAN_METHOD(WallProfiler::New) {
   }
 }
 
+#undef DD_WALL_PROFILER_GET_BOOLEAN_CONFIG
+
 NAN_METHOD(WallProfiler::Start) {
   WallProfiler* wallProfiler =
       Nan::ObjectWrap::Unwrap<WallProfiler>(info.Holder());
@@ -1052,6 +1035,9 @@ int64_t GetAsyncIdNoGC(v8::Isolate* isolate) {
 }
 
 int64_t WallProfiler::GetAsyncId(v8::Isolate* isolate) {
+  if (!collectAsyncId_) {
+    return -1;
+  }
   auto curGcCount = gcCount.load(std::memory_order_relaxed);
   std::atomic_signal_fence(std::memory_order_acquire);
   if (curGcCount > 0) {
diff --git a/bindings/profilers/wall.hh b/bindings/profilers/wall.hh
@@ -71,6 +71,7 @@ class WallProfiler : public Nan::ObjectWrap {
   bool workaroundV8Bug_;
   static inline constexpr bool detectV8Bug_ = true;
   bool collectCpuTime_;
+  bool collectAsyncId_;
   bool isMainThread_;
   int v8ProfilerStuckEventLoopDetected_ = 0;
   ProcessCpuClock::time_point startProcessCpuTime_{};
@@ -120,6 +121,7 @@ class WallProfiler : public Nan::ObjectWrap {
                         bool withContexts,
                         bool workaroundV8bug,
                         bool collectCpuTime,
+                        bool collectAsyncId,
                         bool isMainThread);
 
   v8::Local<v8::Value> GetContext(v8::Isolate*);
diff --git a/ts/src/time-profiler.ts b/ts/src/time-profiler.ts
@@ -66,6 +66,7 @@ export interface TimeProfilerOptions {
   withContexts?: boolean;
   workaroundV8Bug?: boolean;
   collectCpuTime?: boolean;
+  collectAsyncId?: boolean;
 }
 
 const DEFAULT_OPTIONS: TimeProfilerOptions = {
@@ -75,6 +76,7 @@ const DEFAULT_OPTIONS: TimeProfilerOptions = {
   withContexts: false,
   workaroundV8Bug: true,
   collectCpuTime: false,
+  collectAsyncId: false,
 };
 
 export async function profile(options: TimeProfilerOptions = {}) {
diff --git a/ts/test/test-time-profiler.ts b/ts/test/test-time-profiler.ts
@@ -39,7 +39,7 @@ describe('Time Profiler', () => {
       assert.equal(profile.stringTable.strings!.indexOf('(program)'), -1);
     });
 
-    it('should update state', function () {
+    it('should update state', function shouldUpdateState() {
       if (process.platform !== 'darwin' && process.platform !== 'linux') {
         this.skip();
       }
@@ -90,7 +90,7 @@ describe('Time Profiler', () => {
       assert(checked, 'No context found');
     });
 
-    it('should assign labels', function () {
+    it('should have labels', function shouldHaveLabels() {
       if (process.platform !== 'darwin' && process.platform !== 'linux') {
         this.skip();
       }
@@ -129,10 +129,8 @@ describe('Time Profiler', () => {
         if (!context) {
           return {};
         }
-        assert(
-          typeof context.asyncId === 'number',
-          'context.asyncId should be a number'
-        );
+        // Does not collect async IDs by default
+        assert(typeof context.asyncId === 'undefined');
         const labels: LabelSet = {};
         for (const [key, value] of Object.entries(context.context ?? {})) {
           if (typeof value === 'string') {
@@ -356,6 +354,51 @@ describe('Time Profiler', () => {
     });
   });
 
+  it('should have async IDs when enabled', async function shouldCollectAsyncIDs() {
+    if (process.platform !== 'darwin' && process.platform !== 'linux') {
+      this.skip();
+    }
+    this.timeout(3000);
+
+    time.start({
+      intervalMicros: PROFILE_OPTIONS.intervalMicros,
+      durationMillis: PROFILE_OPTIONS.durationMillis,
+      withContexts: true,
+      lineNumbers: false,
+      collectAsyncId: true,
+    });
+    let setDone: () => void;
+    const done = new Promise<void>(resolve => {
+      setDone = resolve;
+    });
+
+    const testStart = hrtime.bigint();
+    const testDurationNanos = PROFILE_OPTIONS.durationMillis * 1_000_000;
+    setTimeout(loop, 0);
+
+    function loop() {
+      const loopDurationNanos = PROFILE_OPTIONS.intervalMicros * 1_000;
+      const loopStart = hrtime.bigint();
+      while (hrtime.bigint() - loopStart < loopDurationNanos);
+      if (hrtime.bigint() - testStart < testDurationNanos) {
+        setTimeout(loop, 0);
+      } else {
+        setDone();
+      }
+    }
+
+    await done;
+
+    let asyncIdObserved = false;
+    time.stop(false, ({context}: GenerateTimeLabelsArgs) => {
+      if (!asyncIdObserved && typeof context?.asyncId === 'number') {
+        asyncIdObserved = context?.asyncId !== -1;
+      }
+      return {};
+    });
+    assert(asyncIdObserved, 'Async ID was not observed');
+  });
+
   describe('profile (w/ stubs)', () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const sinonStubs: Array<sinon.SinonStub<any, any>> = [];
