feat(node): add continuous profiling mode (#12124)

This PR introduce a new continuous profiling mode. This mode is
exclusive from the current mode which considers starting and stopping
profiles on a per span basis.

I've picked the interval duration of 5s as somewhat arbitrarily. The
idea is that we dont want profiles to grow too large, because that might
become a performance issue in the event that we have a lot of deep stack
samples to process.

Since profiling mode is exclusive, we will require users to add a
profilerMode (subject to change) as the SDK option (this is subject to
change as we align the APIs cross sdks). In terms of convenience, we are
likely also going to add a Sentry.profiler.start/stop methods so that
users can have access as to when they can start and stop the profiler
(not implemented as we havent standardized on the approach yet) -
currently this relies on
getIntegrationByName("ProfilingIntegration").profiler.stop

Since the UI does not support this mode yet, I will hide the
profilerMode hidden and only allow the current automated instrumentation

Author: JonasBa

packages/profiling-node/bindings/cpu_profiler.cc

@@ -7,7 +7,13 @@ import { getAbi } from 'node-abi';
 
 import { GLOBAL_OBJ, logger } from '@sentry/utils';
 import { DEBUG_BUILD } from './debug-build';
-import type { PrivateV8CpuProfilerBindings, V8CpuProfilerBindings } from './types';
+import type {
+  PrivateV8CpuProfilerBindings,
+  RawChunkCpuProfile,
+  RawThreadCpuProfile,
+  V8CpuProfilerBindings,
+} from './types';
+import type { ProfileFormat } from './types';
 
 const stdlib = familySync();
 const platform = process.env['BUILD_PLATFORM'] || _platform();
@@ -151,24 +157,39 @@ export function importCppBindingsModule(): PrivateV8CpuProfilerBindings {
 }
 
 const PrivateCpuProfilerBindings: PrivateV8CpuProfilerBindings = importCppBindingsModule();
-const CpuProfilerBindings: V8CpuProfilerBindings = {
-  startProfiling(name: string) {
+
+class Bindings implements V8CpuProfilerBindings {
+  public startProfiling(name: string): void {
     if (!PrivateCpuProfilerBindings) {
       DEBUG_BUILD && logger.log('[Profiling] Bindings not loaded, ignoring call to startProfiling.');
       return;
     }
 
     return PrivateCpuProfilerBindings.startProfiling(name);
-  },
-  stopProfiling(name: string) {
+  }
+
+  public stopProfiling(name: string, format: ProfileFormat.THREAD): RawThreadCpuProfile | null;
+  public stopProfiling(name: string, format: ProfileFormat.CHUNK): RawChunkCpuProfile | null;
+  public stopProfiling(
+    name: string,
+    format: ProfileFormat.CHUNK | ProfileFormat.THREAD,
+  ): RawThreadCpuProfile | RawChunkCpuProfile | null {
     if (!PrivateCpuProfilerBindings) {
       DEBUG_BUILD &&
         logger.log('[Profiling] Bindings not loaded or profile was never started, ignoring call to stopProfiling.');
       return null;
     }
-    return PrivateCpuProfilerBindings.stopProfiling(name, threadId, !!GLOBAL_OBJ._sentryDebugIds);
-  },
-};
+
+    return PrivateCpuProfilerBindings.stopProfiling(
+      name,
+      format as unknown as any,
+      threadId,
+      !!GLOBAL_OBJ._sentryDebugIds,
+    );
+  }
+}
+
+const CpuProfilerBindings = new Bindings();
 
 export { PrivateCpuProfilerBindings };
 export { CpuProfilerBindings };