@platformatic/watt-extra 1.10.1-alpha.2 → 1.11.0-alpha.0

package/.claude/settings.local.json

@@ -1,22 +1,11 @@
 {
   "permissions": {
     "allow": [
-      "Read(//work/workspaces/workspace-platformatic/platformatic/**)",
-      "Bash(npx borp:*)",
-      "Bash(timeout 30 npx borp -c 1 --timeout=20000 ./test/trigger-flamegraphs.test.js)",
-      "Bash(xargs cat:*)",
-      "Bash(pnpm install)",
-      "Bash(find:*)",
-      "Bash(cat:*)",
-      "WebFetch(domain:github.com)",
+      "Bash(node --test-only:*)",
       "Bash(node --test:*)",
-      "Bash(for i in 1 2 3)",
-      "Bash(do echo \"Run $i:\")",
-      "Bash(done)",
-      "Bash(git stash:*)",
-      "Bash(echo:*)",
-      "Bash(grep:*)",
-      "Bash(gh api:*)"
+      "Bash(for i in {1..3})",
+      "Bash(do echo \"=== Run $i ===\")",
+      "Bash(done)"
     ],
     "deny": [],
     "ask": []

package/lib/watt.js

@@ -513,8 +513,7 @@ class Watt {
     const config = runtime.getRuntimeConfig(true)
 
     for (const app of config.applications ?? []) {
-      this.#logger.info({ name: app.id, type: app.type }, `Configuring service ${app.id} of type ${app.type}`)
-      if (app.type === '@platformatic/next') {
+      if (app.type === 'next') {
         await this.#configureNextService(runtime, app)
       } else if (
         [
@@ -531,8 +530,6 @@ class Watt {
   async #configureNextService (runtime, service) {
     let nextSchema
 
-    this.#logger.info(`Configuring next service: ${service}`)
-
     try {
       const nextPackage = createRequire(
         resolve(service.path, 'index.js')
@@ -550,13 +547,9 @@ class Watt {
 
     const patches = []
 
-    const isCacheIsSchema = 'cache' in nextSchema.properties
-    this.#logger.info(`'cache' in nextSchema.properties: ${isCacheIsSchema}`)
-
-    if (isCacheIsSchema) {
+    if ('cache' in nextSchema.properties) {
       const httpCache = this.#instanceConfig?.httpCache?.clientOpts || {}
       const { keyPrefix, host, port, username, password } = httpCache
-      this.#logger.info({ keyPrefix, host, port }, `Configuring cache for next service ${service.id}`)
 
       if (!keyPrefix || !host || !port) {
         this.#logger.warn(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/watt-extra",
-  "version": "1.10.1-alpha.2",
+  "version": "1.11.0-alpha.0",
   "description": "The Platformatic runtime manager",
   "type": "module",
   "scripts": {
@@ -24,7 +24,7 @@
     "@platformatic/node": "^3.25.0",
     "@platformatic/service": "^3.25.0",
     "atomic-sleep": "^1.0.0",
-    "borp": "^0.21.0",
+    "borp": "^1.0.0",
     "eslint": "9",
     "fastify": "^5.4.0",
     "fastify-plugin": "^5.0.1",

package/plugins/env.js

@@ -26,8 +26,10 @@ const schema = {
     PLT_JWT_EXPIRATION_OFFSET_SEC: { type: 'number', default: 60 },
     PLT_UPDATES_RECONNECT_INTERVAL_SEC: { type: 'number', default: 1 },
     PLT_ELU_HEALTH_SIGNAL_THRESHOLD: { type: 'number', default: 0.8 },
-    PLT_HEAP_HEALTH_SIGNAL_THRESHOLD: { type: ['number', 'string'], default: '4GB' },
-    PLT_ALERTS_GRACE_PERIOD_SEC: { type: 'number', default: 30 }
+    PLT_HEAP_HEALTH_SIGNAL_THRESHOLD: { type: ['number', 'string'], default: '200MB' },
+    PLT_ALERTS_GRACE_PERIOD_SEC: { type: 'number', default: 30 },
+    PLT_HEALTH_SIGNALS_SHORT_BATCH_TIMEOUT: { type: 'number', default: 5000 },
+    PLT_HEALTH_SIGNALS_LONG_BATCH_TIMEOUT: { type: 'number', default: 30000 }
   }
 }
 

package/plugins/health-signals.js

@@ -1,42 +1,60 @@
+import { randomUUID } from 'node:crypto'
 import { request } from 'undici'
 import semver from 'semver'
 import { parseMemorySize } from '@platformatic/foundation'
 
 class HealthSignalsCache {
-  #signals = []
-  #size = 100
+  #signalsByService = {}
+  #maxSize = 500
 
-  constructor () {
-    this.#signals = []
-  }
-
-  add (signals) {
+  addServiceSignals (serviceId, signals) {
     for (const signal of signals) {
-      this.#signals.push(signal)
+      this.addServiceSignal(serviceId, signal.type, signal)
     }
-    if (this.#signals.length > this.#size) {
-      this.#signals.splice(0, this.#signals.length - this.#size)
+  }
+
+  addServiceSignal (serviceId, signalType, signal) {
+    this.#signalsByService[serviceId] ??= {}
+    this.#signalsByService[serviceId][signalType] ??= []
+
+    const signals = this.#signalsByService[serviceId][signalType]
+    signals.push(signal)
+
+    if (signals.length > this.#maxSize) {
+      signals.splice(0, signals.length - this.#maxSize)
     }
   }
 
-  getAll () {
-    const values = this.#signals
-    this.#signals = []
-    return values
+  getAllSignals () {
+    const signalsByService = this.#signalsByService
+    this.#signalsByService = {}
+    return signalsByService
   }
 }
 
 async function healthSignals (app, _opts) {
-  const signalsCaches = {}
-  const servicesSendingStatuses = {}
+  app.getRuntimeId = () => {
+    if (!app.runtimeId) {
+      app.runtimeId = randomUUID()
+      process._rawDebug(`[health-signals] Generated new runtimeId: ${app.runtimeId}`)
+    }
+    return app.runtimeId
+  }
+
+  const signalsCache = new HealthSignalsCache()
+  const heapTotalByService = {}
 
   // TODO: needed to the UI compatibility
   // remove after depricating the Scaler v1 UI
-  const servicesMetrics = {}
+  let servicesMetrics = {}
 
   // Store listener reference for cleanup
   let healthMetricsListener = null
 
+  // Store thresholds for use in sendHealthSignals
+  let eluThreshold = null
+  let heapThresholdMb = null
+
   async function setupHealthSignals () {
     const scalerAlgorithmVersion = app.instanceConfig?.scaler?.version ?? 'v1'
     if (scalerAlgorithmVersion !== 'v2') {
@@ -54,13 +72,6 @@ async function healthSignals (app, _opts) {
       return
     }
 
-    const eluThreshold = app.env.PLT_ELU_HEALTH_SIGNAL_THRESHOLD
-
-    let heapThreshold = app.env.PLT_HEAP_HEALTH_SIGNAL_THRESHOLD
-    if (typeof heapThreshold === 'string') {
-      heapThreshold = parseMemorySize(heapThreshold)
-    }
-
     // Skip alerts setup if ICC is not configured
     if (!app.env.PLT_ICC_URL) {
       app.log.info('PLT_ICC_URL not set, skipping alerts setup')
@@ -68,8 +79,6 @@ async function healthSignals (app, _opts) {
     }
 
     const scalerUrl = app.instanceConfig?.iccServices?.scaler?.url
-    const runtime = app.watt.runtime
-
     if (!scalerUrl) {
       app.log.warn(
         'No scaler URL found in ICC services, health alerts disabled'
@@ -77,6 +86,51 @@ async function healthSignals (app, _opts) {
       return
     }
 
+    const runtime = app.watt.runtime
+    const batchShortTimeout = app.env.PLT_HEALTH_SIGNALS_SHORT_BATCH_TIMEOUT
+    const batchLongTimeout = app.env.PLT_HEALTH_SIGNALS_LONG_BATCH_TIMEOUT
+    eluThreshold = app.env.PLT_ELU_HEALTH_SIGNAL_THRESHOLD
+
+    // TODO: get the used heap and use the 0.8 by default as a threshold
+    let heapThreshold = app.env.PLT_HEAP_HEALTH_SIGNAL_THRESHOLD
+    if (typeof heapThreshold === 'string') {
+      heapThreshold = parseMemorySize(heapThreshold)
+    }
+    heapThresholdMb = Math.round(heapThreshold / 1024 / 1024)
+
+    process._rawDebug(`[health-signals] Config: eluThreshold=${eluThreshold}, heapThresholdMb=${heapThresholdMb}, batchShortTimeout=${batchShortTimeout}ms, batchLongTimeout=${batchLongTimeout}ms`)
+
+    let batchHasHighValue = false
+    let batchStartedAt = null
+    setInterval(() => {
+      const now = Date.now()
+      const batchTimeout = batchHasHighValue
+        ? batchShortTimeout
+        : batchLongTimeout
+
+      if (batchStartedAt !== null) {
+        const elapsed = now - batchStartedAt
+        process._rawDebug(`[health-signals] Batch check: elapsed=${elapsed}ms, timeout=${batchTimeout}ms, hasHighValue=${batchHasHighValue}`)
+      }
+
+      if (now - batchStartedAt >= batchTimeout) {
+        process._rawDebug(`[health-signals] Batch timeout reached, sending signals. hasHighValue=${batchHasHighValue}`)
+        batchHasHighValue = false
+        batchStartedAt = null
+
+        const signals = signalsCache.getAllSignals()
+        const metrics = servicesMetrics
+        servicesMetrics = {}
+
+        const serviceIds = Object.keys(signals)
+        process._rawDebug(`[health-signals] Sending signals for services: ${serviceIds.join(', ') || '(none)'}`)
+
+        sendHealthSignals(signals, metrics).catch(err => {
+          app.log.error({ err }, 'Failed to send health signals to scaler')
+        })
+      }
+    }, 1000).unref()
+
     // Remove old listener if it exists (for ICC recovery scenario)
     if (healthMetricsListener) {
       runtime.removeListener('application:worker:health:metrics', healthMetricsListener)
@@ -95,30 +149,32 @@ async function healthSignals (app, _opts) {
       } = healthInfo
 
       const { elu, heapUsed, heapTotal } = currentHealth
+      const heapUsedMb = Math.round(heapUsed / 1024 / 1024)
+      const now = Date.now()
 
-      if (elu > eluThreshold) {
-        healthSignals.push({
-          type: 'elu',
-          value: currentHealth.elu,
-          description:
-            `The ${serviceId} has an ELU of ${(elu * 100).toFixed(2)} %, ` +
-              `above the maximum allowed usage of ${(eluThreshold * 100).toFixed(2)} %`,
-          timestamp: Date.now()
-        })
-      }
+      const eluExceedsThreshold = elu > eluThreshold
+      const heapExceedsThreshold = heapUsedMb > heapThresholdMb
+      process._rawDebug(`[health-signals] Received metrics: service=${serviceId}, worker=${workerId}, elu=${(elu * 100).toFixed(2)}% (threshold=${(eluThreshold * 100).toFixed(2)}%, exceeds=${eluExceedsThreshold}), heap=${heapUsedMb}MB (threshold=${heapThresholdMb}MB, exceeds=${heapExceedsThreshold}), customSignals=${healthSignals.length}`)
 
-      if (heapThreshold && heapUsed > heapThreshold) {
-        const usedHeapMb = Math.round(heapUsed / 1024 / 1024)
-        const heapThresholdMb = Math.round(heapThreshold / 1024 / 1024)
-
-        healthSignals.push({
-          type: 'heapUsed',
-          value: currentHealth.heapUsed,
-          description:
-            `The ${serviceId} is using ${usedHeapMb} MB of heap, ` +
-              `above the maximum allowed usage of ${heapThresholdMb} MB`,
-          timestamp: Date.now()
-        })
+      signalsCache.addServiceSignal(serviceId, 'elu', {
+        workerId,
+        value: elu,
+        timestamp: now
+      })
+      signalsCache.addServiceSignal(serviceId, 'heap', {
+        workerId,
+        value: heapUsedMb,
+        timestamp: now
+      })
+      heapTotalByService[serviceId] = heapTotal
+      signalsCache.addServiceSignals(serviceId, healthSignals)
+
+      batchStartedAt ??= now
+      if (eluExceedsThreshold || heapExceedsThreshold) {
+        if (!batchHasHighValue) {
+          process._rawDebug(`[health-signals] High value detected! Switching to short batch timeout`)
+        }
+        batchHasHighValue = true
       }
 
       // TODO: needed to the UI compatibility
@@ -132,44 +188,42 @@ async function healthSignals (app, _opts) {
         metrics.heapUsed = heapUsed
         metrics.heapTotal = heapTotal
       }
-
-      if (healthSignals.length > 0) {
-        await sendHealthSignalsWithTimeout(serviceId, workerId, healthSignals)
-      }
     }
     runtime.on('application:worker:health:metrics', healthMetricsListener)
   }
   app.setupHealthSignals = setupHealthSignals
 
-  async function sendHealthSignalsWithTimeout (serviceId, workerId, signals) {
-    signalsCaches[serviceId] ??= new HealthSignalsCache()
-    servicesSendingStatuses[serviceId] ??= false
-
-    const signalsCache = signalsCaches[serviceId]
-    signalsCache.add(signals)
-
-    if (!servicesSendingStatuses[serviceId]) {
-      servicesSendingStatuses[serviceId] = true
-      setTimeout(async () => {
-        servicesSendingStatuses[serviceId] = false
-
-        const metrics = servicesMetrics[serviceId]
-        servicesMetrics[serviceId] = null
+  async function sendHealthSignals (rawSignals) {
+    const scalerUrl = app.instanceConfig?.iccServices?.scaler?.url
+    const applicationId = app.instanceConfig?.applicationId
+    const authHeaders = await app.getAuthorizationHeader()
 
-        try {
-          const signals = signalsCache.getAll()
-          await sendHealthSignals(serviceId, workerId, signals, metrics)
-        } catch (err) {
-          app.log.error({ err }, 'Failed to send health signals to scaler')
+    // Transform signals to the format expected by ICC LoadPredictor
+    const signals = {}
+    for (const [serviceId, serviceSignals] of Object.entries(rawSignals)) {
+      signals[serviceId] = {
+        elu: {
+          values: serviceSignals.elu || [],
+          options: { threshold: eluThreshold }
+        },
+        heap: {
+          values: serviceSignals.heap || [],
+          options: {
+            threshold: heapThresholdMb,
+            heapTotal: heapTotalByService[serviceId] || 0
+          }
         }
-      }, 5000).unref()
+      }
+      process._rawDebug(`[health-signals] Prepared signals for ${serviceId}: eluValues=${signals[serviceId].elu.values.length}, heapValues=${signals[serviceId].heap.values.length}, heapTotal=${signals[serviceId].heap.options.heapTotal}`)
     }
-  }
 
-  async function sendHealthSignals (serviceId, workerId, signals, metrics) {
-    const scalerUrl = app.instanceConfig?.iccServices?.scaler?.url
-    const applicationId = app.instanceConfig?.applicationId
-    const authHeaders = await app.getAuthorizationHeader()
+    if (Object.keys(signals).length === 0) {
+      process._rawDebug(`[health-signals] No signals to send, skipping request`)
+      return
+    }
+
+    const runtimeId = app.getRuntimeId()
+    process._rawDebug(`[health-signals] Sending to ${scalerUrl}/signals: applicationId=${applicationId}, runtimeId=${runtimeId}`)
 
     const { statusCode, body } = await request(`${scalerUrl}/signals`, {
       method: 'POST',
@@ -177,30 +231,43 @@ async function healthSignals (app, _opts) {
         'Content-Type': 'application/json',
         ...authHeaders
       },
-      body: JSON.stringify({
-        applicationId,
-        serviceId,
-        signals,
-        elu: metrics.elu,
-        heapUsed: metrics.heapUsed,
-        heapTotal: metrics.heapTotal
-      })
+      body: JSON.stringify({ applicationId, runtimeId, signals })
     })
 
+    process._rawDebug(`[health-signals] Scaler response: statusCode=${statusCode}`)
+
     if (statusCode !== 200) {
       const error = await body.text()
+      process._rawDebug(`[health-signals] Scaler error response: ${error}`)
       app.log.error({ error }, 'Failed to send health signals to scaler')
+      return
     }
 
-    const alert = await body.json()
+    const { alerts = [] } = await body.json()
+    process._rawDebug(`[health-signals] Received ${alerts.length} alerts from scaler`)
 
-    app.sendFlamegraphs({
-      serviceIds: [serviceId],
-      workerIds: [workerId],
-      alertId: alert.id
-    }).catch(err => {
-      app.log.error({ err }, 'Failed to send a flamegraph')
-    })
+    const promises = []
+
+    for (const alert of alerts) {
+      const { serviceId, workerId, alertId } = alert
+      process._rawDebug(`[health-signals] Processing alert: alertId=${alertId}, serviceId=${serviceId}, workerId=${workerId}`)
+      const promise = app.sendFlamegraphs({
+        serviceIds: [serviceId],
+        workerIds: [workerId],
+        alertId
+      })
+      promises.push(promise)
+    }
+    const results = await Promise.allSettled(promises)
+
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        process._rawDebug(`[health-signals] Flamegraph send failed: ${result.reason}`)
+        app.log.error({ err: result.reason }, 'Failed to send a flamegraph')
+      } else {
+        process._rawDebug(`[health-signals] Flamegraph sent successfully`)
+      }
+    }
   }
 }
 

package/plugins/update.js

@@ -2,11 +2,14 @@ import WebSocket from 'ws'
 import { once } from 'node:events'
 import { setTimeout as sleep } from 'node:timers/promises'
 
-function createWebSocketUrl (httpUrl, path) {
+function createWebSocketUrl (httpUrl, path, queryParams = {}) {
   const url = new URL(httpUrl)
   url.protocol = url.protocol.replace('http', 'ws')
   const basePath = url.pathname.endsWith('/') ? url.pathname : `${url.pathname}/`
   url.pathname = `${basePath}${path}`
+  for (const [key, value] of Object.entries(queryParams)) {
+    url.searchParams.set(key, value)
+  }
   return url.toString()
 }
 
@@ -64,8 +67,9 @@ async function updatePlugin (app) {
       return null
     }
 
-    const wsUrl = createWebSocketUrl(iccUrl, `api/updates/applications/${applicationId}`)
-    app.log.info(`Connecting to updates websocket at ${wsUrl}`)
+    const runtimeId = app.getRuntimeId()
+    const wsUrl = createWebSocketUrl(iccUrl, `api/updates/applications/${applicationId}`, { runtimeId })
+    app.log.info({ runtimeId }, `Connecting to updates websocket at ${wsUrl}`)
 
     try {
       const headers = await app.getAuthorizationHeader()

package/test/health-signals.test.js

@@ -31,7 +31,12 @@ test('should send health signals when service becomes unhealthy', async (t) => {
     processSignals: (req) => {
       assert.equal(req.headers.authorization, 'Bearer test-token')
       receivedSignalReqs.push(req.body)
-      return { id: 'test-alert-id' }
+      // Real ICC returns { alerts: [{ serviceId, workerId, alertId }] }
+      return {
+        alerts: [
+          { serviceId: 'main', workerId: 'main:0', alertId: 'test-alert-id' }
+        ]
+      }
     },
     processFlamegraphs: (req) => {
       const alertId = req.query.alertId
@@ -87,36 +92,53 @@ test('should send health signals when service becomes unhealthy', async (t) => {
     assert.strictEqual(statusCode, 200)
   }
 
-  assert.strictEqual(receivedSignalReqs.length, 1)
+  // Multiple batches may be sent due to timing, verify we received at least one
+  assert.ok(receivedSignalReqs.length >= 1, `Expected at least 1 signal request, got ${receivedSignalReqs.length}`)
 
-  const receivedSignalReq = receivedSignalReqs[0]
-  assert.ok(receivedSignalReq, 'Alert should have been received')
+  // Use the last signal request which should have the most complete data
+  const receivedSignalReq = receivedSignalReqs[receivedSignalReqs.length - 1]
+  assert.ok(receivedSignalReq, 'Signal request should have been received')
   assert.strictEqual(receivedSignalReq.applicationId, applicationId)
-  assert.strictEqual(receivedSignalReq.serviceId, 'main')
-  assert.ok(receivedSignalReq.elu > 0.9)
-  assert.ok(receivedSignalReq.heapUsed > 0)
-  assert.ok(receivedSignalReq.heapTotal > 0)
-
-  const receivedSignals = receivedSignalReq.signals
-  assert.ok(receivedSignals.length > 5)
-
-  const eluSignals = receivedSignals.filter(
-    (signal) => signal.type === 'elu'
-  )
-  const customSignals = receivedSignals.filter(
-    (signal) => signal.type === 'custom'
-  )
-  assert.strictEqual(customSignals.length, 1)
-
-  for (const receivedSignal of eluSignals) {
-    assert.strictEqual(receivedSignal.type, 'elu')
-    assert.ok(receivedSignal.value > 0.9)
-    assert.ok(receivedSignal.timestamp > 0)
+  assert.ok(receivedSignalReq.runtimeId, 'runtimeId should be present')
+  assert.ok(typeof receivedSignalReq.runtimeId === 'string', 'runtimeId should be a string')
+
+  // Verify v2 signals format: { serviceId: { elu: { values, options }, heap: { values, options } } }
+  const signals = receivedSignalReq.signals
+  assert.ok(signals, 'signals should be present')
+  assert.ok(signals.main, 'main service signals should be present')
+
+  // Check ELU signals structure
+  const eluSignals = signals.main.elu
+  assert.ok(eluSignals, 'ELU signals should be present')
+  assert.ok(Array.isArray(eluSignals.values), 'ELU values should be an array')
+  assert.ok(eluSignals.options, 'ELU options should be present')
+  assert.ok(typeof eluSignals.options.threshold === 'number', 'ELU threshold should be a number')
+
+  // Check heap signals structure
+  const heapSignals = signals.main.heap
+  assert.ok(heapSignals, 'Heap signals should be present')
+  assert.ok(Array.isArray(heapSignals.values), 'Heap values should be an array')
+  assert.ok(heapSignals.options, 'Heap options should be present')
+  assert.ok(typeof heapSignals.options.threshold === 'number', 'Heap threshold should be a number')
+
+  // Verify ELU values have the correct structure with workerId
+  assert.ok(eluSignals.values.length > 0, 'Should have ELU values')
+  for (const eluValue of eluSignals.values) {
+    assert.ok(typeof eluValue.value === 'number', 'ELU value should be a number')
+    assert.ok(typeof eluValue.timestamp === 'number', 'ELU timestamp should be a number')
+    assert.ok(typeof eluValue.workerId === 'string', 'ELU workerId should be a string')
   }
-  for (const receivedSignal of customSignals) {
-    assert.strictEqual(receivedSignal.type, 'custom')
-    assert.strictEqual(receivedSignal.value, 42)
-    assert.ok(receivedSignal.timestamp > 0)
+
+  // Check that at least one ELU value is high (from CPU intensive operation)
+  const highEluValue = eluSignals.values.find(v => v.value > 0.9)
+  assert.ok(highEluValue, 'Should have at least one high ELU value')
+
+  // Verify heap values have the correct structure with workerId
+  assert.ok(heapSignals.values.length > 0, 'Should have heap values')
+  for (const heapValue of heapSignals.values) {
+    assert.ok(typeof heapValue.value === 'number', 'Heap value should be a number')
+    assert.ok(typeof heapValue.timestamp === 'number', 'Heap timestamp should be a number')
+    assert.ok(typeof heapValue.workerId === 'string', 'Heap workerId should be a string')
   }
 
   // Wait for the second flamegraph to be generated

package/test/patch-config.test.js

@@ -411,60 +411,3 @@ test('should merge user telemetry config with ICC exporter', async (t) => {
   assert.ok(hasUserSkip, 'User skip pattern should be preserved')
   assert.ok(hasDefaultSkip, 'Default skip pattern should be added')
 })
-
-test('should configure next service with cache', async (t) => {
-  const appName = 'test-app'
-  const applicationId = randomUUID()
-  const applicationPath = join(__dirname, 'fixtures', 'runtime-next')
-  const nextServicePath = join(applicationPath, 'web', 'next')
-
-  await installDeps(t, applicationPath)
-  await installDeps(t, nextServicePath, ['@platformatic/next', 'next'])
-
-  const { execa } = await import('execa')
-  await execa(join(__dirname, '../node_modules/.bin/plt'), ['build'], {
-    cwd: applicationPath,
-  })
-
-  const icc = await startICC(t, {
-    applicationId,
-    port: 3001,
-    controlPlaneResponse: {
-      applicationId,
-      httpCache: {
-        clientOpts: {
-          keyPrefix: 'test-prefix',
-          host: '127.0.0.1',
-          port: 6379,
-          username: 'user',
-          password: 'pass'
-        }
-      }
-    }
-  })
-
-  setUpEnvironment({
-    PLT_APP_NAME: appName,
-    PLT_APP_DIR: applicationPath,
-    PLT_ICC_URL: icc.iccUrl,
-    PLT_APP_PORT: 3043,
-    PLT_METRICS_PORT: 9092
-  })
-
-  const app = await start()
-
-  t.after(async () => {
-    await app.close()
-    await icc.close()
-  })
-
-  const runtimeConfig = app.watt.runtime.getRuntimeConfig(true)
-  const nextApp = runtimeConfig.applications.find(a => a.type === '@platformatic/next')
-  assert.ok(nextApp, 'Next service should be found in applications')
-
-  const nextConfig = await app.watt.runtime.getApplicationConfig(nextApp.id)
-  assert.ok(nextConfig.cache, 'Cache should be configured for next service')
-  assert.strictEqual(nextConfig.cache.adapter, 'valkey')
-  assert.strictEqual(nextConfig.cache.prefix, 'test-prefix')
-  assert.strictEqual(nextConfig.cache.maxTTL, 604800)
-})

package/test/trigger-flamegraphs.test.js

@@ -79,6 +79,7 @@ function createMockApp (port, includeScalerUrl = true, env = {}) {
     }
   }
 
+  let runtimeId = null
   const app = {
     log: {
       info: () => {},
@@ -93,6 +94,12 @@ function createMockApp (port, includeScalerUrl = true, env = {}) {
     getAuthorizationHeader: async () => {
       return { Authorization: 'Bearer test-token' }
     },
+    getRuntimeId: () => {
+      if (!runtimeId) {
+        runtimeId = 'test-runtime-id'
+      }
+      return runtimeId
+    },
     env: {
       PLT_APP_NAME: 'test-app',
       PLT_APP_DIR: '/path/to/app',

package/test/update.test.js

@@ -6,7 +6,8 @@ import updatePlugin from '../plugins/update.js'
 import { once, EventEmitter } from 'node:events'
 import { setTimeout as sleep } from 'node:timers/promises'
 
-function createMockApp (port) {
+function createMockApp (port, options = {}) {
+  let runtimeId = null
   return {
     log: {
       info: () => {},
@@ -20,6 +21,12 @@ function createMockApp (port) {
     getAuthorizationHeader: async () => {
       return { Authorization: 'Bearer test-token' }
     },
+    getRuntimeId: () => {
+      if (!runtimeId) {
+        runtimeId = options.runtimeId || 'test-runtime-id'
+      }
+      return runtimeId
+    },
     env: {
       PLT_APP_NAME: 'test-app',
       PLT_APP_DIR: '/path/to/app',
@@ -92,6 +99,46 @@ test('update plugin connects to websocket', async (t) => {
   equal(!!subscriptionAckLog, true, 'Should log subscription acknowledgment')
 })
 
+test('update plugin includes runtimeId in websocket URL', async (t) => {
+  const ee = new EventEmitter()
+  setUpEnvironment()
+
+  const expectedRuntimeId = 'test-runtime-id-12345'
+  let receivedUrl = null
+
+  // Setup WebSocket server
+  const wss = new WebSocketServer({ port })
+  t.after(async () => wss.close())
+
+  wss.on('connection', (ws, req) => {
+    receivedUrl = req.url
+
+    ws.on('message', (data) => {
+      const message = JSON.parse(data.toString())
+      if (message.command === 'subscribe' && message.topic === '/config') {
+        ws.send(JSON.stringify({ command: 'ack' }))
+        ee.emit('subscriptionAckSent')
+      }
+    })
+  })
+
+  const app = createMockApp(port, { runtimeId: expectedRuntimeId })
+  t.after(() => app.closeUpdates())
+
+  await updatePlugin(app)
+
+  const ack = once(ee, 'subscriptionAckSent')
+  app.connectToUpdates()
+  await ack
+
+  // Verify runtimeId is in the URL query params
+  equal(
+    receivedUrl.includes(`runtimeId=${expectedRuntimeId}`),
+    true,
+    `WebSocket URL should include runtimeId query param. Received URL: ${receivedUrl}`
+  )
+})
+
 test('update plugin handles config update messages', async (t) => {
   const ee = new EventEmitter()
   setUpEnvironment()