@platformatic/watt-extra 1.6.3-alpha.5 → 1.7.0

package/test/trigger-flamegraphs.test.js

@@ -79,16 +79,13 @@ function createMockApp (port, includeScalerUrl = true, env = {}) {
     }
   }
 
-  const createLogger = () => ({
-    info: () => {},
-    error: () => {},
-    warn: () => {},
-    debug: () => {},
-    child: () => createLogger()
-  })
-
   const app = {
-    log: createLogger(),
+    log: {
+      info: () => {},
+      error: () => {},
+      warn: () => {},
+      debug: () => {}
+    },
     instanceConfig: {
       applicationId: 'test-application-id'
     },
@@ -129,19 +126,23 @@ test('setupFlamegraphs should pass sourceMaps from application config to startPr
   const app = createMockApp(port)
   const startProfilingCalls = []
 
-  // Mock getApplicationDetails to return config with sourceMaps per service
-  app.watt.runtime.getApplicationDetails = async (serviceId) => {
-    if (serviceId === 'service-1') {
-      return { id: serviceId, sourceMaps: true }
-    } else if (serviceId === 'service-2') {
-      return { id: serviceId, sourceMaps: false }
+  // Mock getApplicationDetails to return config with sourceMaps for worker IDs
+  app.watt.runtime.getApplicationDetails = async (workerFullId) => {
+    if (workerFullId.startsWith('service-1')) {
+      return { id: workerFullId, sourceMaps: true }
+    } else if (workerFullId.startsWith('service-2')) {
+      return { id: workerFullId, sourceMaps: false }
     }
-    return { id: serviceId, sourceMaps: false }
+    return { id: workerFullId, sourceMaps: false }
+  }
+
+  app.watt.runtime.getRuntimeConfig = async () => {
+    return {}
   }
 
-  app.watt.runtime.sendCommandToApplication = async (workerId, command, options) => {
+  app.watt.runtime.sendCommandToApplication = async (workerFullId, command, options) => {
     if (command === 'startProfiling') {
-      startProfilingCalls.push({ workerId, command, options })
+      startProfilingCalls.push({ workerFullId, command, options })
       return { success: true }
     }
     return { success: false }
@@ -150,24 +151,13 @@ test('setupFlamegraphs should pass sourceMaps from application config to startPr
   await flamegraphsPlugin(app)
   await app.setupFlamegraphs()
 
-  t.after(async () => {
-    await app.cleanupFlamegraphs()
-  })
-
-  // Trigger profiling for both CPU and heap profiles
-  await app.requestFlamegraphs({ profileType: 'cpu' })
-  await app.requestFlamegraphs({ profileType: 'heap' })
-
-  // Wait for profiling to start
-  await sleep(100)
-
-  // Should call startProfiling 4 times: 2 services × 2 profile types (cpu + heap)
-  equal(startProfilingCalls.length, 4, 'Should call startProfiling for both services with cpu and heap')
+  // Should call startProfiling 4 times: 2 workers × 2 profile types (cpu + heap)
+  equal(startProfilingCalls.length, 4, 'Should call startProfiling for both workers with cpu and heap')
 
-  const service1CpuCall = startProfilingCalls.find(c => c.workerId === 'service-1:0' && c.options.type === 'cpu')
-  const service1HeapCall = startProfilingCalls.find(c => c.workerId === 'service-1:0' && c.options.type === 'heap')
-  const service2CpuCall = startProfilingCalls.find(c => c.workerId === 'service-2:0' && c.options.type === 'cpu')
-  const service2HeapCall = startProfilingCalls.find(c => c.workerId === 'service-2:0' && c.options.type === 'heap')
+  const service1CpuCall = startProfilingCalls.find(c => c.workerFullId === 'service-1:0' && c.options.type === 'cpu')
+  const service1HeapCall = startProfilingCalls.find(c => c.workerFullId === 'service-1:0' && c.options.type === 'heap')
+  const service2CpuCall = startProfilingCalls.find(c => c.workerFullId === 'service-2:0' && c.options.type === 'cpu')
+  const service2HeapCall = startProfilingCalls.find(c => c.workerFullId === 'service-2:0' && c.options.type === 'heap')
 
   ok(service1CpuCall, 'Should have called startProfiling for service-1 CPU')
   ok(service1HeapCall, 'Should have called startProfiling for service-1 heap')
@@ -187,13 +177,17 @@ test('setupFlamegraphs should handle missing sourceMaps in application config',
   const startProfilingCalls = []
 
   // Mock getApplicationDetails to return config without sourceMaps
-  app.watt.runtime.getApplicationDetails = async (serviceId) => {
-    return { id: serviceId }
+  app.watt.runtime.getApplicationDetails = async (workerFullId) => {
+    return { id: workerFullId }
+  }
+
+  app.watt.runtime.getRuntimeConfig = async () => {
+    return {}
   }
 
-  app.watt.runtime.sendCommandToApplication = async (workerId, command, options) => {
+  app.watt.runtime.sendCommandToApplication = async (workerFullId, command, options) => {
     if (command === 'startProfiling') {
-      startProfilingCalls.push({ workerId, command, options })
+      startProfilingCalls.push({ workerFullId, command, options })
       return { success: true }
     }
     return { success: false }
@@ -202,18 +196,7 @@ test('setupFlamegraphs should handle missing sourceMaps in application config',
   await flamegraphsPlugin(app)
   await app.setupFlamegraphs()
 
-  t.after(async () => {
-    await app.cleanupFlamegraphs()
-  })
-
-  // Trigger profiling for both CPU and heap profiles
-  await app.requestFlamegraphs({ profileType: 'cpu' })
-  await app.requestFlamegraphs({ profileType: 'heap' })
-
-  // Wait for profiling to start
-  await sleep(100)
-
-  equal(startProfilingCalls.length, 4, 'Should call startProfiling for both services with cpu and heap')
+  equal(startProfilingCalls.length, 4, 'Should call startProfiling for both workers with cpu and heap')
 
   for (const call of startProfilingCalls) {
     equal(call.options.sourceMaps, false, 'sourceMaps should be false when not in config')
@@ -229,9 +212,9 @@ test('setupFlamegraphs should skip profiling when PLT_DISABLE_FLAMEGRAPHS is set
 
   const startProfilingCalls = []
 
-  app.watt.runtime.sendCommandToApplication = async (workerId, command, options) => {
+  app.watt.runtime.sendCommandToApplication = async (serviceId, command, options) => {
     if (command === 'startProfiling') {
-      startProfilingCalls.push({ workerId, command, options })
+      startProfilingCalls.push({ serviceId, command, options })
       return { success: true }
     }
     return { success: false }
@@ -240,16 +223,10 @@ test('setupFlamegraphs should skip profiling when PLT_DISABLE_FLAMEGRAPHS is set
   await flamegraphsPlugin(app)
   await app.setupFlamegraphs()
 
-  // Also try to send flamegraphs
-  await app.requestFlamegraphs()
-
-  // Wait to ensure no profiling starts
-  await sleep(100)
-
   equal(startProfilingCalls.length, 0, 'Should not call startProfiling when disabled')
 })
 
-test('requestFlamegraphs should handle errors when starting profiling', async (t) => {
+test('setupFlamegraphs should handle errors when starting profiling', async (t) => {
   setUpEnvironment()
 
   const app = createMockApp(port)
@@ -259,13 +236,17 @@ test('requestFlamegraphs should handle errors when starting profiling', async (t
     errors.push(result)
   }
 
-  app.watt.runtime.getApplicationDetails = async (serviceId) => {
-    return { id: serviceId, sourceMaps: true }
+  app.watt.runtime.getApplicationDetails = async (workerFullId) => {
+    return { id: workerFullId, sourceMaps: true }
   }
 
-  app.watt.runtime.sendCommandToApplication = async (workerId, command, options) => {
+  app.watt.runtime.getRuntimeConfig = async () => {
+    return {}
+  }
+
+  app.watt.runtime.sendCommandToApplication = async (workerFullId, command, options) => {
     if (command === 'startProfiling') {
-      throw new Error(`Failed to start profiling for ${workerId}`)
+      throw new Error(`Failed to start profiling for ${workerFullId}`)
     }
     return { success: false }
   }
@@ -273,21 +254,11 @@ test('requestFlamegraphs should handle errors when starting profiling', async (t
   await flamegraphsPlugin(app)
   await app.setupFlamegraphs()
 
-  t.after(async () => {
-    await app.cleanupFlamegraphs()
-  })
-
-  // Trigger profiling which will fail
-  await app.requestFlamegraphs()
-
-  // Wait for errors to be logged
-  await sleep(100)
-
-  // Should log 2 errors (1 per service in Profiler)
-  equal(errors.length, 2, 'Should log errors for both failed services')
+  // Should log 4 errors (2 workers, each logged twice: once in startProfilingOnWorker, once in setupFlamegraphs)
+  equal(errors.length, 4, 'Should log errors for both failed workers')
 })
 
-test('requestFlamegraphs should upload flamegraphs from all services', async (t) => {
+test('sendFlamegraphs should upload flamegraphs from all services', async (t) => {
   setUpEnvironment()
 
   const uploadedFlamegraphs = []
@@ -297,13 +268,7 @@ test('requestFlamegraphs should upload flamegraphs from all services', async (t)
 
   const mockProfile = new Uint8Array([1, 2, 3, 4, 5])
 
-  app.watt.runtime.sendCommandToApplication = async (workerId, command, options) => {
-    if (command === 'startProfiling') {
-      return { success: true }
-    }
-    if (command === 'getProfilingState') {
-      return { latestProfileTimestamp: Date.now() }
-    }
+  app.watt.runtime.sendCommandToApplication = async (serviceId, command) => {
     if (command === 'getLastProfile') {
       return mockProfile
     }
@@ -323,7 +288,7 @@ test('requestFlamegraphs should upload flamegraphs from all services', async (t)
         body: buffer
       })
       res.writeHead(200)
-      res.end(JSON.stringify({ id: 'flamegraph-id' }))
+      res.end()
     })
   })
 
@@ -331,17 +296,7 @@ test('requestFlamegraphs should upload flamegraphs from all services', async (t)
   t.after(() => server.close())
 
   await flamegraphsPlugin(app)
-  await app.setupFlamegraphs()
-
-  t.after(async () => {
-    await app.cleanupFlamegraphs()
-  })
-
-  // Trigger profiling
-  await app.requestFlamegraphs()
-
-  // Wait for profile to be generated (duration is 1 second)
-  await sleep(1500)
+  await app.sendFlamegraphs()
 
   equal(uploadedFlamegraphs.length, 2, 'Should upload flamegraphs for both services')
 
@@ -356,7 +311,7 @@ test('requestFlamegraphs should upload flamegraphs from all services', async (t)
   deepEqual(service1Upload.body, Buffer.from(mockProfile))
 })
 
-test('requestFlamegraphs should handle missing profile data', async (t) => {
+test('sendFlamegraphs should handle missing profile data', async (t) => {
   setUpEnvironment()
 
   const app = createMockApp(port + 11)
@@ -366,13 +321,7 @@ test('requestFlamegraphs should handle missing profile data', async (t) => {
     errors.push(obj)
   }
 
-  app.watt.runtime.sendCommandToApplication = async (workerId, command) => {
-    if (command === 'startProfiling') {
-      return { success: true }
-    }
-    if (command === 'getProfilingState') {
-      return { latestProfileTimestamp: Date.now() }
-    }
+  app.watt.runtime.sendCommandToApplication = async (serviceId, command) => {
     if (command === 'getLastProfile') {
       // Return invalid data (not Uint8Array)
       return null
@@ -381,34 +330,18 @@ test('requestFlamegraphs should handle missing profile data', async (t) => {
   }
 
   await flamegraphsPlugin(app)
-  await app.setupFlamegraphs()
-
-  t.after(async () => {
-    await app.cleanupFlamegraphs()
-  })
-
-  // Trigger profiling
-  await app.requestFlamegraphs()
-
-  // Wait for profile to be generated (duration is 1 second)
-  await sleep(1500)
+  await app.sendFlamegraphs()
 
   equal(errors.length, 2, 'Should log errors for both services with missing profiles')
 })
 
-test('requestFlamegraphs should filter by workerIds when provided', async (t) => {
+test('sendFlamegraphs should filter by workerIds when provided', async (t) => {
   setUpEnvironment()
 
   const app = createMockApp(port + 12)
   const getProfileCalls = []
 
   app.watt.runtime.sendCommandToApplication = async (workerId, command) => {
-    if (command === 'startProfiling') {
-      return { success: true }
-    }
-    if (command === 'getProfilingState') {
-      return { latestProfileTimestamp: Date.now() }
-    }
     if (command === 'getLastProfile') {
       getProfileCalls.push(workerId)
       return new Uint8Array([1, 2, 3])
@@ -423,7 +356,7 @@ test('requestFlamegraphs should filter by workerIds when provided', async (t) =>
     req.on('data', chunk => body.push(chunk))
     req.on('end', () => {
       res.writeHead(200)
-      res.end(JSON.stringify({ id: 'flamegraph-id' }))
+      res.end()
     })
   })
 
@@ -431,23 +364,52 @@ test('requestFlamegraphs should filter by workerIds when provided', async (t) =>
   t.after(() => server.close())
 
   await flamegraphsPlugin(app)
-  await app.setupFlamegraphs()
+  await app.sendFlamegraphs({ workerIds: ['service-1:0'] })
 
-  t.after(async () => {
-    await app.cleanupFlamegraphs()
+  equal(getProfileCalls.length, 1, 'Should only request profile for specified service')
+  equal(getProfileCalls[0], 'service-1:0', 'Should request profile for service-1')
+})
+
+test('sendFlamegraphs should try to get the profile from a service if worker is not available', async (t) => {
+  setUpEnvironment()
+
+  const app = createMockApp(port + 12)
+  const getProfileCalls = []
+
+  app.watt.runtime.sendCommandToApplication = async (workerId, command) => {
+    if (command === 'getLastProfile') {
+      getProfileCalls.push(workerId)
+      if (workerId === 'service-1:2') {
+        throw new Error('Worker not available')
+      }
+      return new Uint8Array([1, 2, 3])
+    }
+    return { success: false }
+  }
+
+  // Mock HTTP server
+  const { createServer } = await import('node:http')
+  const server = createServer((req, res) => {
+    const body = []
+    req.on('data', chunk => body.push(chunk))
+    req.on('end', () => {
+      res.writeHead(200)
+      res.end()
+    })
   })
 
-  // Trigger profiling for specific worker
-  await app.requestFlamegraphs({ workerIds: ['service-1:0'] })
+  await new Promise(resolve => server.listen(port + 12, resolve))
+  t.after(() => server.close())
 
-  // Wait for profile to be generated (duration is 1 second)
-  await sleep(1500)
+  await flamegraphsPlugin(app)
+  await app.sendFlamegraphs({ workerIds: ['service-1:2'] })
 
-  equal(getProfileCalls.length, 1, 'Should only request profile for specified service')
-  equal(getProfileCalls[0], 'service-1:0', 'Should request profile for service-1')
+  equal(getProfileCalls.length, 2)
+  equal(getProfileCalls[0], 'service-1:2')
+  equal(getProfileCalls[1], 'service-1')
 })
 
-test('requestFlamegraphs should skip when PLT_DISABLE_FLAMEGRAPHS is set', async (t) => {
+test('sendFlamegraphs should skip when PLT_DISABLE_FLAMEGRAPHS is set', async (t) => {
   setUpEnvironment()
 
   const app = createMockApp(port + 13)
@@ -456,9 +418,6 @@ test('requestFlamegraphs should skip when PLT_DISABLE_FLAMEGRAPHS is set', async
   const getProfileCalls = []
 
   app.watt.runtime.sendCommandToApplication = async (workerId, command) => {
-    if (command === 'startProfiling') {
-      return { success: true }
-    }
     if (command === 'getLastProfile') {
       getProfileCalls.push(workerId)
       return new Uint8Array([1, 2, 3])
@@ -467,15 +426,12 @@ test('requestFlamegraphs should skip when PLT_DISABLE_FLAMEGRAPHS is set', async
   }
 
   await flamegraphsPlugin(app)
-  await app.requestFlamegraphs()
-
-  // Wait to ensure no profiling starts
-  await sleep(100)
+  await app.sendFlamegraphs()
 
   equal(getProfileCalls.length, 0, 'Should not request profiles when disabled')
 })
 
-test('requestFlamegraphs should throw error when scaler URL is missing', async (t) => {
+test('sendFlamegraphs should throw error when scaler URL is missing', async (t) => {
   setUpEnvironment()
 
   const app = createMockApp(port + 14, false) // Don't include scaler URL
@@ -484,7 +440,7 @@ test('requestFlamegraphs should throw error when scaler URL is missing', async (
 
   let errorThrown = false
   try {
-    await app.requestFlamegraphs()
+    await app.sendFlamegraphs()
   } catch (err) {
     errorThrown = true
     ok(err.message.includes('No scaler URL'), 'Should throw error about missing scaler URL')
@@ -504,7 +460,7 @@ test('should handle trigger-flamegraph command and upload flamegraphs from servi
   })
 
   const wss = new WebSocketServer({ port: port + 15 })
-  t.after(() => wss.close())
+  t.after(async () => wss.close())
 
   const { waitForClientSubscription, getWs } = setupMockIccServer(
     wss,
@@ -515,17 +471,14 @@ test('should handle trigger-flamegraph command and upload flamegraphs from servi
   const app = createMockApp(port + 15)
 
   app.watt.runtime.sendCommandToApplication = async (
-    workerId,
+    serviceId,
     command
   ) => {
     if (command === 'startProfiling') {
       return { success: true }
     }
-    if (command === 'getProfilingState') {
-      return { latestProfileTimestamp: Date.now() }
-    }
     if (command === 'getLastProfile') {
-      getFlamegraphReqs.push({ serviceId: workerId })
+      getFlamegraphReqs.push({ serviceId })
       if (getFlamegraphReqs.length === 2) {
         uploadResolve()
       }
@@ -542,7 +495,7 @@ test('should handle trigger-flamegraph command and upload flamegraphs from servi
 
   t.after(async () => {
     if (app.cleanupFlamegraphs) {
-      await app.cleanupFlamegraphs()
+      app.cleanupFlamegraphs()
     }
     await app.closeUpdates()
   })
@@ -560,14 +513,14 @@ test('should handle trigger-flamegraph command and upload flamegraphs from servi
   equal(getFlamegraphReqs.length, 2)
 
   const service1Req = getFlamegraphReqs.find(
-    (f) => f.serviceId === 'service-1:0'
+    (f) => f.serviceId === 'service-1'
   )
   const service2Req = getFlamegraphReqs.find(
-    (f) => f.serviceId === 'service-2:0'
+    (f) => f.serviceId === 'service-2'
   )
 
-  equal(service1Req.serviceId, 'service-1:0')
-  equal(service2Req.serviceId, 'service-2:0')
+  equal(service1Req.serviceId, 'service-1')
+  equal(service2Req.serviceId, 'service-2')
 })
 
 test('should handle trigger-flamegraph when no runtime is available', async (t) => {
@@ -576,7 +529,7 @@ test('should handle trigger-flamegraph when no runtime is available', async (t)
   const receivedMessages = []
 
   const wss = new WebSocketServer({ port: port + 16 })
-  t.after(() => wss.close())
+  t.after(async () => wss.close())
 
   const { waitForClientSubscription, getWs } = setupMockIccServer(
     wss,
@@ -609,7 +562,7 @@ test('should handle trigger-flamegraph when flamegraph upload fails', async (t)
   const receivedMessages = []
 
   const wss = new WebSocketServer({ port: port + 17 })
-  t.after(() => wss.close())
+  t.after(async () => wss.close())
 
   const { waitForClientSubscription, getWs } = setupMockIccServer(
     wss,
@@ -663,8 +616,8 @@ test('should handle trigger-heapprofile command and upload heap profiles from se
     uploadResolve = resolve
   })
 
-  const wss = new WebSocketServer({ port: port + 18 })
-  t.after(() => wss.close())
+  const wss = new WebSocketServer({ port: port + 3 })
+  t.after(async () => wss.close())
 
   const { waitForClientSubscription, getWs } = setupMockIccServer(
     wss,
@@ -672,10 +625,10 @@ test('should handle trigger-heapprofile command and upload heap profiles from se
     true
   )
 
-  const app = createMockApp(port + 18)
+  const app = createMockApp(port + 3)
 
   app.watt.runtime.sendCommandToApplication = async (
-    workerId,
+    serviceId,
     command,
     options
   ) => {
@@ -685,11 +638,8 @@ test('should handle trigger-heapprofile command and upload heap profiles from se
     if (command === 'startProfiling') {
       return { success: true }
     }
-    if (command === 'getProfilingState') {
-      return { latestProfileTimestamp: Date.now() }
-    }
     if (command === 'getLastProfile') {
-      getHeapProfileReqs.push({ serviceId: workerId })
+      getHeapProfileReqs.push({ serviceId })
       if (getHeapProfileReqs.length === 2) {
         uploadResolve()
       }
@@ -706,7 +656,7 @@ test('should handle trigger-heapprofile command and upload heap profiles from se
 
   t.after(async () => {
     if (app.cleanupFlamegraphs) {
-      await app.cleanupFlamegraphs()
+      app.cleanupFlamegraphs()
     }
     await app.closeUpdates()
   })
@@ -724,30 +674,342 @@ test('should handle trigger-heapprofile command and upload heap profiles from se
   equal(getHeapProfileReqs.length, 2)
 
   const service1Req = getHeapProfileReqs.find(
-    (f) => f.serviceId === 'service-1:0'
+    (f) => f.serviceId === 'service-1'
   )
   const service2Req = getHeapProfileReqs.find(
-    (f) => f.serviceId === 'service-2:0'
+    (f) => f.serviceId === 'service-2'
   )
 
-  equal(service1Req.serviceId, 'service-1:0')
-  equal(service2Req.serviceId, 'service-2:0')
+  equal(service1Req.serviceId, 'service-1')
+  equal(service2Req.serviceId, 'service-2')
 })
 
-test('requestFlamegraphs should include alertId in query params when provided', async (t) => {
+test('should handle PLT_PPROF_NO_PROFILE_AVAILABLE error with info log', async (t) => {
   setUpEnvironment()
 
-  const uploadedRequests = []
+  const receivedMessages = []
+  const infoLogs = []
 
-  const app = createMockApp(port + 19)
+  const wss = new WebSocketServer({ port: port + 4 })
+  t.after(async () => wss.close())
 
-  app.watt.runtime.sendCommandToApplication = async (workerId, command) => {
+  const { waitForClientSubscription, getWs } = setupMockIccServer(
+    wss,
+    receivedMessages,
+    true
+  )
+
+  const app = createMockApp(port + 4, true, {
+    PLT_FLAMEGRAPHS_INTERVAL_SEC: 10,
+    PLT_FLAMEGRAPHS_ATTEMPT_TIMEOUT: 1000
+  })
+
+  const originalInfo = app.log.info
+  app.log.info = (...args) => {
+    originalInfo(...args)
+    infoLogs.push(args)
+  }
+
+  // Profile will be generated in 10s
+  const profileGenerationDate = Date.now() + 10000
+  const mockProfile = new Uint8Array([1, 2, 3, 4, 5])
+
+  app.watt.runtime.sendCommandToApplication = async (
+    serviceId,
+    command
+  ) => {
     if (command === 'startProfiling') {
       return { success: true }
     }
-    if (command === 'getProfilingState') {
-      return { latestProfileTimestamp: Date.now() }
+    if (command === 'getLastProfile') {
+      const now = Date.now()
+      if (now < profileGenerationDate) {
+        const error = new Error('No profile available - wait for profiling to complete or trigger manual capture')
+        error.code = 'PLT_PPROF_NO_PROFILE_AVAILABLE'
+        throw error
+      }
+      return mockProfile
+    }
+    return { success: false }
+  }
+
+  await updatePlugin(app)
+  await flamegraphsPlugin(app)
+
+  await app.connectToUpdates()
+  await app.setupFlamegraphs()
+
+  t.after(async () => {
+    if (app.cleanupFlamegraphs) {
+      app.cleanupFlamegraphs()
+    }
+    await app.closeUpdates()
+  })
+
+  await waitForClientSubscription
+
+  const triggerFlamegraphMessage = {
+    command: 'trigger-flamegraph'
+  }
+
+  getWs().send(JSON.stringify(triggerFlamegraphMessage))
+
+  await sleep(15000)
+
+  const service1AttemptLogs = []
+  const service2AttemptLogs = []
+  const service1SuccessLogs = []
+  const service2SuccessLogs = []
+
+  for (const infoLog of infoLogs) {
+    if (infoLog.length !== 2) continue
+    const [options, message] = infoLog
+
+    if (message.includes('No profile available for the service')) {
+      const { workerId, attempt, maxAttempts, attemptTimeout } = options
+
+      equal(maxAttempts, 11)
+      equal(attemptTimeout, 1000)
+
+      if (workerId === 'service-1') {
+        service1AttemptLogs.push(infoLog)
+        equal(attempt, service1AttemptLogs.length)
+      }
+      if (workerId === 'service-2') {
+        service2AttemptLogs.push(infoLog)
+        equal(attempt, service2AttemptLogs.length)
+      }
+      continue
+    }
+
+    if (message.includes('Sending flamegraph')) {
+      if (options.serviceId === 'service-1') {
+        service1SuccessLogs.push(infoLog)
+      } else if (options.serviceId === 'service-2') {
+        service2SuccessLogs.push(infoLog)
+      }
+    }
+  }
+
+  equal(service1AttemptLogs.length, 10)
+  equal(service2AttemptLogs.length, 10)
+  equal(service1SuccessLogs.length, 1)
+  equal(service2SuccessLogs.length, 1)
+})
+
+test('should handle PLT_PPROF_NOT_ENOUGH_ELU error with info log', async (t) => {
+  setUpEnvironment()
+
+  const receivedMessages = []
+  const infoLogs = []
+  let errorCount = 0
+  let uploadResolve
+  const allUploadsComplete = new Promise((resolve) => {
+    uploadResolve = resolve
+  })
+
+  const wss = new WebSocketServer({ port: port + 5 })
+  t.after(async () => wss.close())
+
+  const { waitForClientSubscription, getWs } = setupMockIccServer(
+    wss,
+    receivedMessages,
+    true
+  )
+
+  const app = createMockApp(port + 5)
+  const originalInfo = app.log.info
+  app.log.info = (...args) => {
+    originalInfo(...args)
+    if (args[1] && args[1].includes('ELU low, CPU profiling not active')) {
+      infoLogs.push(args)
+      errorCount++
+      if (errorCount === 2) {
+        uploadResolve()
+      }
+    }
+  }
+
+  app.watt.runtime.sendCommandToApplication = async (
+    serviceId,
+    command
+  ) => {
+    if (command === 'startProfiling') {
+      return { success: true }
     }
+    if (command === 'getLastProfile') {
+      const error = new Error('No profile available - event loop utilization has been below threshold for too long')
+      error.code = 'PLT_PPROF_NOT_ENOUGH_ELU'
+      throw error
+    }
+    return { success: false }
+  }
+
+  await updatePlugin(app)
+  await flamegraphsPlugin(app)
+
+  await app.connectToUpdates()
+  await app.setupFlamegraphs()
+
+  t.after(async () => {
+    if (app.cleanupFlamegraphs) {
+      app.cleanupFlamegraphs()
+    }
+    await app.closeUpdates()
+  })
+
+  await waitForClientSubscription
+
+  const triggerFlamegraphMessage = {
+    command: 'trigger-flamegraph'
+  }
+
+  getWs().send(JSON.stringify(triggerFlamegraphMessage))
+
+  await allUploadsComplete
+
+  equal(infoLogs.length, 2)
+  equal(infoLogs[0][0].workerId, 'service-1')
+  equal(infoLogs[0][1], 'ELU low, CPU profiling not active')
+})
+
+test('should start profiling on new workers that start after initial setup', async (t) => {
+  setUpEnvironment()
+
+  const receivedMessages = []
+  const startProfilingCalls = []
+
+  const wss = new WebSocketServer({ port: port + 6 })
+  t.after(async () => wss.close())
+
+  const { waitForClientSubscription } = setupMockIccServer(
+    wss,
+    receivedMessages,
+    false
+  )
+
+  const app = createMockApp(port + 6)
+
+  app.watt.runtime.sendCommandToApplication = async (
+    serviceId,
+    command,
+    options
+  ) => {
+    if (command === 'startProfiling') {
+      startProfilingCalls.push({ serviceId, options })
+    }
+    return { success: true }
+  }
+
+  await updatePlugin(app)
+  await flamegraphsPlugin(app)
+
+  await app.connectToUpdates()
+  await app.setupFlamegraphs()
+
+  t.after(async () => {
+    if (app.cleanupFlamegraphs) {
+      app.cleanupFlamegraphs()
+    }
+    await app.closeUpdates()
+  })
+
+  await waitForClientSubscription
+
+  equal(startProfilingCalls.length, 4)
+  equal(startProfilingCalls[0].serviceId, 'service-1:0')
+  equal(startProfilingCalls[0].options.type, 'cpu')
+  equal(startProfilingCalls[1].serviceId, 'service-1:0')
+  equal(startProfilingCalls[1].options.type, 'heap')
+  equal(startProfilingCalls[2].serviceId, 'service-2:0')
+  equal(startProfilingCalls[2].options.type, 'cpu')
+  equal(startProfilingCalls[3].serviceId, 'service-2:0')
+  equal(startProfilingCalls[3].options.type, 'heap')
+
+  app.watt.runtime.emit('application:worker:started', {
+    application: 'service-1',
+    worker: 1,
+    workersCount: 2
+  })
+
+  await sleep(10)
+
+  equal(startProfilingCalls.length, 6)
+  equal(startProfilingCalls[4].serviceId, 'service-1:1')
+  equal(startProfilingCalls[4].options.durationMillis, 1000)
+  equal(startProfilingCalls[4].options.eluThreshold, 0)
+  equal(startProfilingCalls[4].options.type, 'cpu')
+  equal(startProfilingCalls[5].serviceId, 'service-1:1')
+  equal(startProfilingCalls[5].options.durationMillis, 1000)
+  equal(startProfilingCalls[5].options.eluThreshold, 0)
+  equal(startProfilingCalls[5].options.type, 'heap')
+})
+
+test('should not start profiling on new workers when flamegraphs are disabled', async (t) => {
+  setUpEnvironment()
+
+  const receivedMessages = []
+  const startProfilingCalls = []
+
+  const wss = new WebSocketServer({ port: port + 7 })
+  t.after(async () => wss.close())
+
+  const { waitForClientSubscription } = setupMockIccServer(
+    wss,
+    receivedMessages,
+    false
+  )
+
+  const app = createMockApp(port + 7)
+  app.env.PLT_DISABLE_FLAMEGRAPHS = true
+
+  app.watt.runtime.sendCommandToApplication = async (
+    serviceId,
+    command,
+    options
+  ) => {
+    if (command === 'startProfiling') {
+      startProfilingCalls.push({ serviceId, options })
+    }
+    return { success: true }
+  }
+
+  await updatePlugin(app)
+  await flamegraphsPlugin(app)
+
+  await app.connectToUpdates()
+  await app.setupFlamegraphs()
+
+  t.after(async () => {
+    if (app.cleanupFlamegraphs) {
+      app.cleanupFlamegraphs()
+    }
+    await app.closeUpdates()
+  })
+
+  await waitForClientSubscription
+
+  equal(startProfilingCalls.length, 0)
+
+  app.watt.runtime.emit('application:worker:started', {
+    application: 'service-1',
+    worker: 1,
+    workersCount: 2
+  })
+
+  await sleep(10)
+
+  equal(startProfilingCalls.length, 0)
+})
+
+test('sendFlamegraphs should include alertId in query params when provided', async (t) => {
+  setUpEnvironment()
+
+  const uploadedRequests = []
+
+  const app = createMockApp(port + 18)
+
+  app.watt.runtime.sendCommandToApplication = async (serviceId, command) => {
     if (command === 'getLastProfile') {
       return new Uint8Array([1, 2, 3])
     }
@@ -765,25 +1027,15 @@ test('requestFlamegraphs should include alertId in query params when provided',
         method: req.method
       })
       res.writeHead(200)
-      res.end(JSON.stringify({ id: 'flamegraph-id' }))
+      res.end()
     })
   })
 
-  await new Promise(resolve => server.listen(port + 19, resolve))
+  await new Promise(resolve => server.listen(port + 18, resolve))
   t.after(() => server.close())
 
   await flamegraphsPlugin(app)
-  await app.setupFlamegraphs()
-
-  t.after(async () => {
-    await app.cleanupFlamegraphs()
-  })
-
-  // Trigger profiling with alertId
-  await app.requestFlamegraphs({ alertId: 'test-alert-123' })
-
-  // Wait for profile to be generated (duration is 1 second)
-  await sleep(1500)
+  await app.sendFlamegraphs({ alertId: 'test-alert-123' })
 
   equal(uploadedRequests.length, 2, 'Should upload flamegraphs for both services')