@platformatic/wattpm-pprof-capture 3.8.0 → 3.10.0

package/index.js

@@ -1,11 +1,21 @@
-import { time } from '@datadog/pprof'
+import { time, heap } from '@datadog/pprof'
 import { NoProfileAvailableError, ProfilingAlreadyStartedError, ProfilingNotStartedError } from './lib/errors.js'
 
 const kITC = Symbol.for('plt.runtime.itc')
 
-let isCapturing = false
-let latestProfile = null
-let captureInterval = null
+// Track profiling state separately for each type
+const profilingState = {
+  cpu: {
+    isCapturing: false,
+    latestProfile: null,
+    captureInterval: null
+  },
+  heap: {
+    isCapturing: false,
+    latestProfile: null,
+    captureInterval: null
+  }
+}
 
 // Keep trying until ITC is available. This is needed because preloads run
 // before the app thread initialization, so globalThis.platformatic.messaging
@@ -19,51 +29,101 @@ const registerInterval = setInterval(() => {
   }
 }, 10)
 
-function rotateProfile () {
-  // `true` immediately restarts profiling after stopping
-  latestProfile = time.stop(true)
+function getProfiler (type) {
+  return type === 'heap' ? heap : time
+}
+
+function rotateProfile (type) {
+  const profiler = getProfiler(type)
+  const state = profilingState[type]
+
+  if (type === 'heap') {
+    // Heap profiler needs to call profile() to get the current profile
+    state.latestProfile = profiler.profile()
+  } else {
+    // CPU time profiler: `true` immediately restarts profiling after stopping
+    state.latestProfile = profiler.stop(true)
+  }
 }
 
 export function startProfiling (options = {}) {
-  if (isCapturing) {
+  const type = options.type || 'cpu'
+  const state = profilingState[type]
+
+  if (state.isCapturing) {
     throw new ProfilingAlreadyStartedError()
   }
-  isCapturing = true
+  state.isCapturing = true
 
-  time.start(options)
+  const profiler = getProfiler(type)
+
+  // Heap profiler has different API than time profiler
+  if (type === 'heap') {
+    // Heap profiler takes intervalBytes and stackDepth as positional arguments
+    // Default: 512KB interval, 64 stack depth
+    const intervalBytes = options.intervalBytes || 512 * 1024
+    const stackDepth = options.stackDepth || 64
+    profiler.start(intervalBytes, stackDepth)
+  } else {
+    // CPU time profiler takes options object
+    profiler.start(options)
+  }
 
   // Set up profile window rotation if durationMillis is provided
   const timeout = options.durationMillis
   if (timeout) {
-    captureInterval = setInterval(rotateProfile, timeout)
-    captureInterval.unref()
+    state.captureInterval = setInterval(() => rotateProfile(type), timeout)
+    state.captureInterval.unref()
   }
 }
 
-export function stopProfiling () {
-  if (!isCapturing) {
+export function stopProfiling (options = {}) {
+  const type = options.type || 'cpu'
+  const state = profilingState[type]
+
+  if (!state.isCapturing) {
     throw new ProfilingNotStartedError()
   }
-  isCapturing = false
+  state.isCapturing = false
 
-  clearInterval(captureInterval)
-  captureInterval = null
+  clearInterval(state.captureInterval)
+  state.captureInterval = null
 
-  latestProfile = time.stop()
-  return latestProfile.encode()
+  const profiler = getProfiler(type)
+
+  // Heap and CPU profilers have different stop APIs
+  if (type === 'heap') {
+    // Get the profile before stopping
+    state.latestProfile = profiler.profile()
+    profiler.stop()
+  } else {
+    // CPU time profiler returns the profile when stopping
+    state.latestProfile = profiler.stop()
+  }
+
+  return state.latestProfile.encode()
 }
 
-export function getLastProfile () {
+export function getLastProfile (options = {}) {
+  const type = options.type || 'cpu'
+  const state = profilingState[type]
+
   // TODO: Should it be allowed to get last profile after stopping?
-  if (!isCapturing) {
+  if (!state.isCapturing) {
     throw new ProfilingNotStartedError()
   }
 
-  if (latestProfile == null) {
+  const profiler = getProfiler(type)
+
+  // For heap profiler, always get the current profile
+  // For CPU profiler, use the cached profile if available
+  if (type === 'heap') {
+    state.latestProfile = profiler.profile()
+  } else if (state.latestProfile == null) {
     throw new NoProfileAvailableError()
   }
 
-  return latestProfile.encode()
+  return state.latestProfile.encode()
 }
 
 export * as errors from './lib/errors.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/wattpm-pprof-capture",
-  "version": "3.8.0",
+  "version": "3.10.0",
   "description": "pprof profiling capture for wattpm",
   "main": "index.js",
   "type": "module",
@@ -22,8 +22,8 @@
   "devDependencies": {
     "eslint": "9",
     "neostandard": "^0.12.0",
-    "@platformatic/service": "3.8.0",
-    "@platformatic/foundation": "3.8.0"
+    "@platformatic/foundation": "3.10.0",
+    "@platformatic/service": "3.10.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/test/watt-pprof-capture.test.js

@@ -200,3 +200,119 @@ test('getLastProfile should return same profile until next rotation', async t =>
 
   await app.sendCommandToApplication('service', 'stopProfiling')
 })
+
+test('heap profiling should work', async t => {
+  const { app } = await createApp(t)
+
+  // Start heap profiling
+  await app.sendCommandToApplication('service', 'startProfiling', { type: 'heap' })
+
+  // Wait a bit for some allocations
+  await new Promise(resolve => setTimeout(resolve, 200))
+
+  // Stop heap profiling and get profile
+  const profile = await app.sendCommandToApplication('service', 'stopProfiling', { type: 'heap' })
+  assert.ok(profile instanceof Uint8Array, 'Heap profile should be Uint8Array')
+  assert.ok(profile.length > 0, 'Heap profile should have content')
+})
+
+test('heap profiling should throw error when not started', async t => {
+  const { app } = await createApp(t)
+
+  // Try to stop heap profiling without starting
+  await assert.rejects(
+    () => app.sendCommandToApplication('service', 'stopProfiling', { type: 'heap' }),
+    { code: 'PLT_PPROF_PROFILING_NOT_STARTED' },
+    'Should throw ProfilingNotStartedError for heap profiling'
+  )
+})
+
+test('heap profiling multiple start attempts should throw error', async t => {
+  const { app } = await createApp(t)
+
+  // Start heap profiling
+  await app.sendCommandToApplication('service', 'startProfiling', { type: 'heap' })
+
+  // Try to start again - should throw ProfilingAlreadyStartedError
+  await assert.rejects(
+    () => app.sendCommandToApplication('service', 'startProfiling', { type: 'heap' }),
+    { code: 'PLT_PPROF_PROFILING_ALREADY_STARTED' },
+    'Should throw ProfilingAlreadyStartedError for heap profiling'
+  )
+
+  await app.sendCommandToApplication('service', 'stopProfiling', { type: 'heap' })
+})
+
+test('concurrent CPU and heap profiling should work', async t => {
+  const { app } = await createApp(t)
+
+  // Start both CPU and heap profiling
+  await app.sendCommandToApplication('service', 'startProfiling', { type: 'cpu' })
+  await app.sendCommandToApplication('service', 'startProfiling', { type: 'heap' })
+
+  // Wait a bit for data
+  await new Promise(resolve => setTimeout(resolve, 200))
+
+  // Stop both and get profiles
+  const cpuProfile = await app.sendCommandToApplication('service', 'stopProfiling', { type: 'cpu' })
+  const heapProfile = await app.sendCommandToApplication('service', 'stopProfiling', { type: 'heap' })
+
+  assert.ok(cpuProfile instanceof Uint8Array, 'CPU profile should be Uint8Array')
+  assert.ok(cpuProfile.length > 0, 'CPU profile should have content')
+  assert.ok(heapProfile instanceof Uint8Array, 'Heap profile should be Uint8Array')
+  assert.ok(heapProfile.length > 0, 'Heap profile should have content')
+})
+
+test('heap profiling getLastProfile should return current heap snapshot', async t => {
+  const { app } = await createApp(t)
+
+  // Start heap profiling
+  await app.sendCommandToApplication('service', 'startProfiling', { type: 'heap' })
+
+  // Wait a bit for allocations
+  await new Promise(resolve => setTimeout(resolve, 200))
+
+  // Get last profile should work for heap (returns current snapshot)
+  const profile1 = await app.sendCommandToApplication('service', 'getLastProfile', { type: 'heap' })
+  assert.ok(profile1 instanceof Uint8Array, 'Heap profile should be Uint8Array')
+  assert.ok(profile1.length > 0, 'Heap profile should have content')
+
+  // Get another snapshot
+  await new Promise(resolve => setTimeout(resolve, 100))
+  const profile2 = await app.sendCommandToApplication('service', 'getLastProfile', { type: 'heap' })
+  assert.ok(profile2 instanceof Uint8Array, 'Heap profile should be Uint8Array')
+
+  await app.sendCommandToApplication('service', 'stopProfiling', { type: 'heap' })
+})
+
+test('CPU and heap profiling are independent', async t => {
+  const { app } = await createApp(t)
+
+  // Start only CPU profiling
+  await app.sendCommandToApplication('service', 'startProfiling', { type: 'cpu' })
+
+  // Heap profiling should not be started
+  await assert.rejects(
+    () => app.sendCommandToApplication('service', 'stopProfiling', { type: 'heap' }),
+    { code: 'PLT_PPROF_PROFILING_NOT_STARTED' },
+    'Heap profiling should not be started'
+  )
+
+  // CPU profiling should work
+  const cpuProfile = await app.sendCommandToApplication('service', 'stopProfiling', { type: 'cpu' })
+  assert.ok(cpuProfile instanceof Uint8Array, 'CPU profile should work')
+
+  // Now start heap profiling
+  await app.sendCommandToApplication('service', 'startProfiling', { type: 'heap' })
+
+  // CPU profiling should not be started anymore
+  await assert.rejects(
+    () => app.sendCommandToApplication('service', 'stopProfiling', { type: 'cpu' }),
+    { code: 'PLT_PPROF_PROFILING_NOT_STARTED' },
+    'CPU profiling should not be started'
+  )
+
+  // Heap profiling should work
+  const heapProfile = await app.sendCommandToApplication('service', 'stopProfiling', { type: 'heap' })
+  assert.ok(heapProfile instanceof Uint8Array, 'Heap profile should work')
+})