@platformatic/wattpm-pprof-capture 3.11.0 → 3.13.0

package/index.js

@@ -1,19 +1,46 @@
 import { time, heap } from '@datadog/pprof'
-import { NoProfileAvailableError, ProfilingAlreadyStartedError, ProfilingNotStartedError } from './lib/errors.js'
+import { performance } from 'node:perf_hooks'
+import { NoProfileAvailableError, NotEnoughELUError, ProfilingAlreadyStartedError, ProfilingNotStartedError } from './lib/errors.js'
 
 const kITC = Symbol.for('plt.runtime.itc')
 
+// Track ELU globally (shared across all profiler types)
+let lastELU = null
+let previousELU = performance.eventLoopUtilization()
+
+// Start continuous ELU tracking immediately
+const eluUpdateInterval = setInterval(() => {
+  lastELU = performance.eventLoopUtilization(previousELU)
+  previousELU = performance.eventLoopUtilization()
+
+  for (const type of ['cpu', 'heap']) {
+    const state = profilingState[type]
+    startIfOverThreshold(type, state)
+  }
+}, 1000)
+eluUpdateInterval.unref()
+
 // Track profiling state separately for each type
 const profilingState = {
   cpu: {
     isCapturing: false,
     latestProfile: null,
-    captureInterval: null
+    captureInterval: null,
+    durationMillis: null,
+    eluThreshold: null,
+    options: null,
+    profilerStarted: false,
+    clearProfileTimeout: null
   },
   heap: {
     isCapturing: false,
     latestProfile: null,
-    captureInterval: null
+    captureInterval: null,
+    durationMillis: null,
+    eluThreshold: null,
+    options: null,
+    profilerStarted: false,
+    clearProfileTimeout: null
   }
 }
 
@@ -25,6 +52,7 @@ const registerInterval = setInterval(() => {
     globalThis[kITC].handle('getLastProfile', getLastProfile)
     globalThis[kITC].handle('startProfiling', startProfiling)
     globalThis[kITC].handle('stopProfiling', stopProfiling)
+    globalThis[kITC].handle('getProfilingState', getProfilingState)
     clearInterval(registerInterval)
   }
 }, 10)
@@ -33,31 +61,52 @@ function getProfiler (type) {
   return type === 'heap' ? heap : time
 }
 
-function rotateProfile (type) {
-  const profiler = getProfiler(type)
-  const state = profilingState[type]
+function scheduleLastProfileCleanup (state) {
+  unscheduleLastProfileCleanup(state)
 
-  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)
+  // Set up timer to clear profile after rotation duration
+  if (state.options?.durationMillis) {
+    state.clearProfileTimeout = setTimeout(() => {
+      state.latestProfile = undefined
+      state.clearProfileTimeout = null
+    }, state.options.durationMillis)
+    state.clearProfileTimeout.unref()
   }
 }
 
-export function startProfiling (options = {}) {
-  const type = options.type || 'cpu'
-  const state = profilingState[type]
+function unscheduleLastProfileCleanup (state) {
+  // Clear any pending profile clear timeout
+  if (state.clearProfileTimeout) {
+    clearTimeout(state.clearProfileTimeout)
+    state.clearProfileTimeout = null
+  }
+}
 
-  if (state.isCapturing) {
-    throw new ProfilingAlreadyStartedError()
+function scheduleProfileRotation (type, state, options) {
+  unscheduleProfileRotation(state)
+
+  // Set up profile window rotation if durationMillis is provided
+  if (options.durationMillis) {
+    state.captureInterval = setInterval(() => rotateProfile(type), options.durationMillis)
+    state.captureInterval.unref()
   }
-  state.isCapturing = true
+}
+
+function unscheduleProfileRotation (state) {
+  if (!state.captureInterval) return
+  clearInterval(state.captureInterval)
+  state.captureInterval = null
+}
+
+function startProfiler (type, state, options) {
+  if (state.profilerStarted) return
 
   const profiler = getProfiler(type)
 
-  // Heap profiler has different API than time profiler
+  unscheduleLastProfileCleanup(state)
+  scheduleProfileRotation(type, state, options)
+  state.profilerStarted = true
+
   if (type === 'heap') {
     // Heap profiler takes intervalBytes and stackDepth as positional arguments
     // Default: 512KB interval, 64 stack depth
@@ -66,17 +115,109 @@ export function startProfiling (options = {}) {
     profiler.start(intervalBytes, stackDepth)
   } else {
     // CPU time profiler takes options object
+    options.intervalMicros ??= 33333
     profiler.start(options)
   }
+}
 
-  // Set up profile window rotation if durationMillis is provided
-  const timeout = options.durationMillis
-  if (timeout) {
-    state.captureInterval = setInterval(() => rotateProfile(type), timeout)
-    state.captureInterval.unref()
+function stopProfiler (type, state) {
+  if (!state.profilerStarted) return
+
+  const profiler = getProfiler(type)
+
+  scheduleLastProfileCleanup(state)
+  unscheduleProfileRotation(state)
+  state.profilerStarted = false
+
+  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()
+  }
+}
+
+function isAboveThreshold (state) {
+  return lastELU != null && lastELU.utilization > state.eluThreshold
+}
+
+function isBelowStopThreshold (state) {
+  // Use hysteresis: stop at threshold - 0.1 to prevent rapid toggling
+  const stopThreshold = state.eluThreshold - 0.1
+  return lastELU != null && lastELU.utilization < stopThreshold
+}
+
+function rotateProfile (type) {
+  const state = profilingState[type]
+  const wasRunning = state.profilerStarted
+
+  stopProfiler(type, state)
+  maybeStartProfiler(type, state, wasRunning)
+}
+
+function maybeStartProfiler (type, state, wasRunning) {
+  // Check if we should start profiling based on current ELU (updated by global interval)
+  if (state.eluThreshold != null) {
+    startIfOverThreshold(type, state, wasRunning)
+  } else if (state.isCapturing) {
+    // No threshold, always start profiling
+    startProfiler(type, state, state.options)
+  }
+}
+
+function startIfOverThreshold (type, state, wasRunning = state.profilerStarted) {
+  // Only check if profiling is active and has an ELU threshold
+  if (!state.isCapturing || state.eluThreshold == null) {
+    return
+  }
+
+  const currentELU = lastELU?.utilization
+
+  // Hysteresis logic:
+  // - Start if ELU > threshold
+  // - Stop if ELU < threshold - 0.1
+  // - Between thresholds: maintain current state
+  const shouldRun = wasRunning
+    // Was running: only stop if ELU drops below stop threshold
+    ? !isBelowStopThreshold(state)
+    // Was not running: only start if ELU rises above start threshold
+    : isAboveThreshold(state)
+
+  if (shouldRun) {
+    // ELU is high enough, start/restart profiling
+    if (!wasRunning && !state.profilerStarted && globalThis.platformatic?.logger) {
+      globalThis.platformatic.logger.debug(
+        { type, eluThreshold: state.eluThreshold, currentELU },
+        'Starting profiler due to ELU threshold exceeded'
+      )
+    }
+    startProfiler(type, state, state.options)
+  } else if (!shouldRun && wasRunning && globalThis.platformatic?.logger && state.eluThreshold != null) {
+    // Log when deciding not to restart after stopping (only in rotation context)
+    globalThis.platformatic.logger.debug(
+      { type, eluThreshold: state.eluThreshold, currentELU },
+      'Pausing profiler due to ELU below threshold'
+    )
   }
 }
 
+export function startProfiling (options = {}) {
+  const type = options.type || 'cpu'
+  const state = profilingState[type]
+
+  if (state.isCapturing) {
+    throw new ProfilingAlreadyStartedError()
+  }
+  state.isCapturing = true
+  state.options = options
+  state.eluThreshold = options.eluThreshold
+  state.durationMillis = options.durationMillis
+
+  maybeStartProfiler(type, state)
+}
+
 export function stopProfiling (options = {}) {
   const type = options.type || 'cpu'
   const state = profilingState[type]
@@ -86,22 +227,20 @@ export function stopProfiling (options = {}) {
   }
   state.isCapturing = false
 
-  clearInterval(state.captureInterval)
-  state.captureInterval = null
+  stopProfiler(type, state)
 
-  const profiler = getProfiler(type)
+  // Clean up state
+  state.eluThreshold = null
+  state.durationMillis = null
+  state.options = null
 
-  // Heap and CPU profilers have different stop APIs
-  if (type === 'heap') {
-    // Get the profile before stopping
-    state.latestProfile = profiler.profile()
-    profiler.stop()
+  // Return the latest profile if available, otherwise return an empty profile
+  // (e.g., when profiler never started due to ELU threshold not being exceeded)
+  if (state.latestProfile) {
+    return state.latestProfile.encode()
   } else {
-    // CPU time profiler returns the profile when stopping
-    state.latestProfile = profiler.stop()
+    return new Uint8Array(0)
   }
-
-  return state.latestProfile.encode()
 }
 
 export function getLastProfile (options = {}) {
@@ -113,17 +252,40 @@ export function getLastProfile (options = {}) {
     throw new ProfilingNotStartedError()
   }
 
-  const profiler = getProfiler(type)
-
-  // For heap profiler, always get the current profile
+  // For heap profiler, always get the current profile (if actually profiling)
   // For CPU profiler, use the cached profile if available
-  if (type === 'heap') {
+  if (type === 'heap' && state.profilerStarted) {
+    const profiler = getProfiler(type)
     state.latestProfile = profiler.profile()
-  } else if (state.latestProfile == null) {
-    throw new NoProfileAvailableError()
+  }
+
+  // Check if we have a profile
+  if (state.latestProfile == null) {
+    // No profile available
+    if (state.profilerStarted) {
+      // Profiler is running but no profile yet (waiting for first rotation)
+      throw new NoProfileAvailableError()
+    } else {
+      // Profiler is not running (paused due to low ELU or never started)
+      throw new NotEnoughELUError()
+    }
   }
 
   return state.latestProfile.encode()
 }
 
+export function getProfilingState (options = {}) {
+  const type = options.type || 'cpu'
+  const state = profilingState[type]
+
+  return {
+    isCapturing: state.isCapturing,
+    hasProfile: state.latestProfile != null,
+    isProfilerRunning: state.profilerStarted,
+    isPausedBelowThreshold: state.eluThreshold != null && !state.profilerStarted,
+    lastELU: lastELU?.utilization,
+    eluThreshold: state.eluThreshold
+  }
+}
+
 export * as errors from './lib/errors.js'

package/lib/errors.js

@@ -19,3 +19,9 @@ export const NoProfileAvailableError = createError(
   'No profile available - wait for profiling to complete or trigger manual capture',
   400
 )
+
+export const NotEnoughELUError = createError(
+  `${ERROR_PREFIX}_NOT_ENOUGH_ELU`,
+  'No profile available - event loop utilization has been below threshold for too long',
+  400
+)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/wattpm-pprof-capture",
-  "version": "3.11.0",
+  "version": "3.13.0",
   "description": "pprof profiling capture for wattpm",
   "main": "index.js",
   "type": "module",
@@ -20,10 +20,11 @@
     "undici": "^6.0.0"
   },
   "devDependencies": {
+    "atomic-sleep": "^1.0.0",
     "eslint": "9",
     "neostandard": "^0.12.0",
-    "@platformatic/foundation": "3.11.0",
-    "@platformatic/service": "3.11.0"
+    "@platformatic/service": "3.13.0",
+    "@platformatic/foundation": "3.13.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/test/fixtures/runtime-test/service/plugin.js

@@ -1,6 +1,14 @@
 'use strict'
 
+const atomicSleep = require('atomic-sleep')
+
+function sleep (ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
 module.exports = async function (app) {
+  let cpuIntensiveInterval = null
+
   // Simple hello world service
   app.get('/', async () => {
     return { message: 'Hello World' }
@@ -10,4 +18,34 @@ module.exports = async function (app) {
   app.get('/health', async () => {
     return { status: 'ok' }
   })
+
+  // CPU intensive endpoint to simulate high ELU
+  app.post('/cpu-intensive/start', async () => {
+    if (cpuIntensiveInterval) {
+      return { message: 'Already running' }
+    }
+
+    cpuIntensiveInterval = setInterval(async () => {
+      atomicSleep(900) // Blocks the event loop for 900ms
+      await sleep(100) // Allows async operations
+    }, 1000)
+
+    return { message: 'CPU intensive task started' }
+  })
+
+  app.post('/cpu-intensive/stop', async () => {
+    if (cpuIntensiveInterval) {
+      clearInterval(cpuIntensiveInterval)
+      cpuIntensiveInterval = null
+      return { message: 'CPU intensive task stopped' }
+    }
+    return { message: 'Not running' }
+  })
+
+  // Clean up on close
+  app.addHook('onClose', async () => {
+    if (cpuIntensiveInterval) {
+      clearInterval(cpuIntensiveInterval)
+    }
+  })
 }

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

@@ -19,6 +19,27 @@ async function createApp (t) {
   return { app, url }
 }
 
+// Helper to wait for a condition to be true
+async function waitForCondition (checkFn, timeoutMs = 5000, pollMs = 100) {
+  const startTime = Date.now()
+  while (Date.now() - startTime < timeoutMs) {
+    if (await checkFn()) {
+      return true
+    }
+    await new Promise(resolve => setTimeout(resolve, pollMs))
+  }
+  throw new Error('Timeout waiting for condition')
+}
+
+// Helper to compare Uint8Arrays
+function arraysEqual (a, b) {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false
+  }
+  return true
+}
+
 test('basic service functionality should work with wattpm-pprof-capture', async t => {
   const { url } = await createApp(t)
 
@@ -48,7 +69,7 @@ test('getLastProfile should throw error when profiling not started', async t =>
 })
 
 test('error types should be distinguishable throughout lifecycle', async t => {
-  const { app } = await createApp(t)
+  const { app, url } = await createApp(t)
 
   // Test ProfilingNotStartedError before starting
   await assert.rejects(
@@ -57,9 +78,37 @@ test('error types should be distinguishable throughout lifecycle', async t => {
     'Should throw ProfilingNotStartedError (not NoProfileAvailableError)'
   )
 
-  // Start profiling with profile rotation
+  // Test NotEnoughELUError when profiling with high threshold (no CPU load)
+  await app.sendCommandToApplication('service', 'startProfiling', { eluThreshold: 2.0, durationMillis: 200 })
+
+  // Wait for profiler to be paused below threshold
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.isPausedBelowThreshold && !state.isProfilerRunning
+  }, 2000)
+
+  // getLastProfile should throw NotEnoughELUError
+  await assert.rejects(
+    () => app.sendCommandToApplication('service', 'getLastProfile'),
+    { code: 'PLT_PPROF_NOT_ENOUGH_ELU' },
+    'Should throw NotEnoughELUError when ELU threshold not exceeded'
+  )
+
+  // Stop profiling
+  await app.sendCommandToApplication('service', 'stopProfiling')
+
+  // Start CPU intensive task to generate load for profiler
+  await request(`${url}/cpu-intensive/start`, { method: 'POST' })
+
+  // Start profiling with profile rotation (no threshold)
   await app.sendCommandToApplication('service', 'startProfiling', { durationMillis: 500 })
 
+  // Wait for profiler to actually start running
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.isProfilerRunning && !state.hasProfile
+  }, 1000)
+
   // Test NoProfileAvailableError (before any rotation happens)
   await assert.rejects(
     () => app.sendCommandToApplication('service', 'getLastProfile'),
@@ -80,6 +129,9 @@ test('error types should be distinguishable throughout lifecycle', async t => {
   assert.ok(stopResult instanceof Uint8Array, 'stopProfiling should return final profile')
   assert.ok(stopResult.length > 0, 'Final profile should have content')
 
+  // Stop CPU intensive task
+  await request(`${url}/cpu-intensive/stop`, { method: 'POST' })
+
   // Test ProfilingNotStartedError after stopping
   await assert.rejects(
     () => app.sendCommandToApplication('service', 'getLastProfile'),
@@ -316,3 +368,282 @@ test('CPU and heap profiling are independent', async t => {
   const heapProfile = await app.sendCommandToApplication('service', 'stopProfiling', { type: 'heap' })
   assert.ok(heapProfile instanceof Uint8Array, 'Heap profile should work')
 })
+
+test('profiling with eluThreshold should not start when below threshold', async t => {
+  const { app } = await createApp(t)
+
+  // Start profiling with a very high threshold (above 1.0, which is impossible)
+  await app.sendCommandToApplication('service', 'startProfiling', { eluThreshold: 2.0, durationMillis: 200 })
+
+  // Wait a bit - profiler should not have started
+  await new Promise(resolve => setTimeout(resolve, 300))
+
+  // getLastProfile should throw NotEnoughELUError since ELU threshold not exceeded
+  await assert.rejects(
+    () => app.sendCommandToApplication('service', 'getLastProfile'),
+    { code: 'PLT_PPROF_NOT_ENOUGH_ELU' },
+    'Should throw NotEnoughELUError when ELU threshold not exceeded'
+  )
+
+  // Stop profiling
+  const profile = await app.sendCommandToApplication('service', 'stopProfiling')
+  assert.ok(profile instanceof Uint8Array, 'Should return Uint8Array')
+  // Profile will be empty or have minimal content since profiler never actually ran
+})
+
+test('profiling with eluThreshold should start when utilization exceeds threshold', async t => {
+  const { app, url } = await createApp(t)
+
+  // Start profiling with a low threshold
+  await app.sendCommandToApplication('service', 'startProfiling', { eluThreshold: 0.5, durationMillis: 500 })
+
+  // Start CPU intensive task to increase ELU
+  await request(`${url}/cpu-intensive/start`, { method: 'POST' })
+
+  // Wait for profiler to actually start running
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.isProfilerRunning
+  }, 3000)
+
+  // Wait for a profile to be captured
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.hasProfile
+  }, 2000)
+
+  // Profile should be available now
+  const profile = await app.sendCommandToApplication('service', 'getLastProfile')
+  assert.ok(profile instanceof Uint8Array, 'Should get profile after threshold exceeded')
+  assert.ok(profile.length > 0, 'Profile should have content')
+
+  // Stop CPU intensive task
+  await request(`${url}/cpu-intensive/stop`, { method: 'POST' })
+
+  await app.sendCommandToApplication('service', 'stopProfiling')
+})
+
+test('profiling with eluThreshold should work with heap profiling', async t => {
+  const { app } = await createApp(t)
+
+  // Start heap profiling with a very high threshold
+  await app.sendCommandToApplication('service', 'startProfiling', { type: 'heap', eluThreshold: 2.0 })
+
+  // Wait a bit - profiler should not have started due to low ELU
+  await new Promise(resolve => setTimeout(resolve, 200))
+
+  // getLastProfile should throw NotEnoughELUError since ELU threshold not exceeded
+  await assert.rejects(
+    () => app.sendCommandToApplication('service', 'getLastProfile', { type: 'heap' }),
+    { code: 'PLT_PPROF_NOT_ENOUGH_ELU' },
+    'Should throw NotEnoughELUError when heap profiler ELU threshold not exceeded'
+  )
+
+  // Stop profiling
+  const profile = await app.sendCommandToApplication('service', 'stopProfiling', { type: 'heap' })
+  assert.ok(profile instanceof Uint8Array, 'Should return Uint8Array')
+})
+
+test('eluThreshold profiling should allow double start error', async t => {
+  const { app } = await createApp(t)
+
+  // Start profiling with eluThreshold
+  await app.sendCommandToApplication('service', 'startProfiling', { eluThreshold: 0.5 })
+
+  // Try to start again - should throw ProfilingAlreadyStartedError
+  await assert.rejects(
+    () => app.sendCommandToApplication('service', 'startProfiling', { eluThreshold: 0.5 }),
+    { code: 'PLT_PPROF_PROFILING_ALREADY_STARTED' },
+    'Should throw ProfilingAlreadyStartedError'
+  )
+
+  await app.sendCommandToApplication('service', 'stopProfiling')
+})
+
+test('profiling with eluThreshold should not start when always below threshold', async t => {
+  const { app } = await createApp(t)
+
+  // Start profiling with very high threshold (impossible to reach without CPU task)
+  await app.sendCommandToApplication('service', 'startProfiling', { eluThreshold: 1.5, durationMillis: 300 })
+
+  // Wait for state to show we're paused below threshold
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.isPausedBelowThreshold && !state.isProfilerRunning
+  }, 2000)
+
+  // Stop profiling - should return empty profile since profiler never started
+  const profileBeforeThreshold = await app.sendCommandToApplication('service', 'stopProfiling')
+  assert.ok(profileBeforeThreshold instanceof Uint8Array, 'Should return Uint8Array')
+  assert.ok(profileBeforeThreshold.length === 0, 'Profile should be empty since profiler never started')
+})
+
+test('profiling with eluThreshold should start when threshold is reached', async t => {
+  const { app, url } = await createApp(t)
+
+  // Start profiling while ELU is low
+  await app.sendCommandToApplication('service', 'startProfiling', { eluThreshold: 0.5, durationMillis: 300 })
+
+  // Start CPU intensive task to raise ELU above threshold
+  await request(`${url}/cpu-intensive/start`, { method: 'POST' })
+
+  // Wait for profiler to actually start running
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.isProfilerRunning
+  }, 3000)
+
+  // Wait for a profile to be captured
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.hasProfile
+  }, 2000)
+
+  // Now profile should be available
+  const profileAfterThreshold = await app.sendCommandToApplication('service', 'getLastProfile')
+  assert.ok(profileAfterThreshold instanceof Uint8Array, 'Should get profile after threshold exceeded')
+  assert.ok(profileAfterThreshold.length > 0, 'Profile should have content after threshold exceeded')
+
+  // Clean up
+  await request(`${url}/cpu-intensive/stop`, { method: 'POST' })
+  await app.sendCommandToApplication('service', 'stopProfiling')
+})
+
+test('profiling with eluThreshold should pause during rotation when below threshold', async t => {
+  const { app, url } = await createApp(t)
+
+  // Start CPU intensive task first
+  await request(`${url}/cpu-intensive/start`, { method: 'POST' })
+
+  // Wait for ELU to rise above threshold
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.lastELU != null && state.lastELU > 0.5
+  }, 3000)
+
+  // Start profiling with threshold and rotation interval
+  await app.sendCommandToApplication('service', 'startProfiling', { eluThreshold: 0.5, durationMillis: 500 })
+
+  // Wait for profiler to start
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.isProfilerRunning
+  }, 2000)
+
+  // Wait for a profile to be captured
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.hasProfile
+  }, 2000)
+
+  // Get first profile - should have content
+  const profile1 = await app.sendCommandToApplication('service', 'getLastProfile')
+  assert.ok(profile1 instanceof Uint8Array, 'First profile should be available')
+  assert.ok(profile1.length > 0, 'First profile should have content')
+
+  // Stop CPU intensive task - ELU should drop below stop threshold (0.4)
+  await request(`${url}/cpu-intensive/stop`, { method: 'POST' })
+
+  // Wait for profiler to detect low ELU and pause
+  // This waits for both ELU to drop AND for the next rotation to detect it
+  // ELU drops slowly as the rolling average window moves past the high-ELU period
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return !state.isProfilerRunning && state.isPausedBelowThreshold
+  }, 15000)
+
+  // Verify profiler has paused
+  const state = await app.sendCommandToApplication('service', 'getProfilingState')
+  assert.ok(!state.isProfilerRunning, 'Profiler should have stopped running')
+  assert.ok(state.isPausedBelowThreshold, 'Should be paused below threshold')
+
+  // Clean up
+  await app.sendCommandToApplication('service', 'stopProfiling')
+})
+
+test('profiling with eluThreshold should start immediately when already above threshold', async t => {
+  const { app, url } = await createApp(t)
+
+  // Start CPU intensive task BEFORE starting profiling
+  await request(`${url}/cpu-intensive/start`, { method: 'POST' })
+
+  // Wait for ELU to actually rise above threshold
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.lastELU != null && state.lastELU > 0.5
+  }, 5000)
+
+  // Now start profiling - should start immediately since ELU is already high
+  await app.sendCommandToApplication('service', 'startProfiling', { eluThreshold: 0.5, durationMillis: 300 })
+
+  // Profiler should start immediately without being paused
+  const stateAfterStart = await app.sendCommandToApplication('service', 'getProfilingState')
+  assert.ok(stateAfterStart.isProfilerRunning, 'Profiler should start immediately when ELU is already high')
+  assert.ok(!stateAfterStart.isPausedBelowThreshold, 'Should not be paused below threshold')
+
+  // Wait for a profile to be captured
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.hasProfile
+  })
+
+  // Profile should be available after first rotation
+  const profile = await app.sendCommandToApplication('service', 'getLastProfile')
+  assert.ok(profile instanceof Uint8Array, 'Profile should be available after rotation')
+  assert.ok(profile.length > 0, 'Profile should have content')
+
+  // Clean up
+  await request(`${url}/cpu-intensive/stop`, { method: 'POST' })
+  await app.sendCommandToApplication('service', 'stopProfiling')
+})
+
+test('profiling with eluThreshold should continue rotating while above threshold', async t => {
+  const { app, url } = await createApp(t)
+
+  // Start CPU intensive task
+  await request(`${url}/cpu-intensive/start`, { method: 'POST' })
+
+  // Wait for ELU to rise above threshold
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.lastELU != null && state.lastELU > 0.5
+  }, 3000)
+
+  // Start profiling with rotation interval
+  await app.sendCommandToApplication('service', 'startProfiling', { eluThreshold: 0.5, durationMillis: 400 })
+
+  // Wait for profiler to start
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.isProfilerRunning
+  }, 2000)
+
+  // Wait for first profile
+  await waitForCondition(async () => {
+    const state = await app.sendCommandToApplication('service', 'getProfilingState')
+    return state.hasProfile
+  }, 2000)
+
+  // Get first profile
+  const profile1 = await app.sendCommandToApplication('service', 'getLastProfile')
+  assert.ok(profile1 instanceof Uint8Array, 'First profile should be available')
+  assert.ok(profile1.length > 0, 'First profile should have content')
+
+  // Wait for second rotation to capture a new profile
+  await waitForCondition(async () => {
+    const profile = await app.sendCommandToApplication('service', 'getLastProfile')
+    return !arraysEqual(profile, profile1)
+  }, 2000)
+
+  // Get second profile
+  const profile2 = await app.sendCommandToApplication('service', 'getLastProfile')
+  assert.ok(profile2 instanceof Uint8Array, 'Second profile should be available')
+  assert.ok(profile2.length > 0, 'Second profile should have content')
+
+  // Profiles should be different (captured at different times)
+  assert.ok(!arraysEqual(profile1, profile2), 'Profiles should be different after rotation')
+
+  // Clean up
+  await request(`${url}/cpu-intensive/stop`, { method: 'POST' })
+  await app.sendCommandToApplication('service', 'stopProfiling')
+})