@platformatic/watt-extra 1.5.3 → 1.6.0-alpha.0

package/.claude/settings.local.json

@@ -3,7 +3,11 @@
     "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(timeout 30 npx borp -c 1 --timeout=20000 ./test/trigger-flamegraphs.test.js)",
+      "Bash(xargs cat:*)",
+      "Bash(pnpm install)",
+      "Bash(find:*)",
+      "Bash(cat:*)"
     ],
     "deny": [],
     "ask": []

package/lib/watt.js

@@ -1,6 +1,7 @@
 import { readFile } from 'node:fs/promises'
 import { join, resolve } from 'node:path'
 import { createRequire } from 'node:module'
+import semver from 'semver'
 
 const require = createRequire(import.meta.url)
 
@@ -103,6 +104,11 @@ class Watt {
     return version
   }
 
+  runtimeSupportsNewHealthMetrics () {
+    const runtimeVersion = this.getRuntimeVersion()
+    return semver.gte(runtimeVersion, '3.18.0')
+  }
+
   async #createRuntime () {
     this.#logger.info('Creating runtime')
     const { create, transform } = this.#require('@platformatic/runtime')
@@ -391,14 +397,26 @@ class Watt {
   }
 
   #configureHealth (config) {
-    config.health = {
-      ...config.health,
-      enabled: true,
-      interval: 1000,
-      maxUnhealthyChecks: 30
+    if (this.runtimeSupportsNewHealthMetrics()) {
+      // New behavior: just force enabled to true, inherit everything else from app config
+      config.health = {
+        ...config.health,
+        enabled: true
+      }
+    } else {
+      config.health = {
+        ...config.health,
+        enabled: true,
+        interval: 1000,
+        maxUnhealthyChecks: 30
+      }
     }
   }
 
+  getHealthConfig () {
+    return this.#config?.health
+  }
+
   #configureScheduler (config) {
     // Disable all watt schedules. We do that because
     // we will create/update them in ICC, not on watt in memory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/watt-extra",
-  "version": "1.5.3",
+  "version": "1.6.0-alpha.0",
   "description": "The Platformatic runtime manager",
   "type": "module",
   "scripts": {
@@ -19,10 +19,10 @@
   },
   "devDependencies": {
     "@fastify/websocket": "^11.1.0",
-    "@platformatic/composer": "^3.14.0",
-    "@platformatic/next": "^3.14.0",
-    "@platformatic/node": "^3.14.0",
-    "@platformatic/service": "^3.14.0",
+    "@platformatic/composer": "^3.18.0",
+    "@platformatic/next": "^3.18.0",
+    "@platformatic/node": "^3.18.0",
+    "@platformatic/service": "^3.18.0",
     "atomic-sleep": "^1.0.0",
     "borp": "^0.21.0",
     "eslint": "9",
@@ -30,16 +30,16 @@
     "fastify-plugin": "^5.0.1",
     "neostandard": "^0.12.0",
     "next": "^16.0.0",
-    "platformatic": "^3.14.0",
+    "platformatic": "^3.18.0",
     "pprof-format": "^2.1.0",
     "why-is-node-running": "^2.3.0"
   },
   "dependencies": {
     "@datadog/pprof": "^5.9.0",
     "@fastify/error": "^4.2.0",
-    "@platformatic/foundation": "^3.14.0",
-    "@platformatic/runtime": "^3.14.0",
-    "@platformatic/wattpm-pprof-capture": "^3.14.0",
+    "@platformatic/foundation": "^3.18.0",
+    "@platformatic/runtime": "^3.18.0",
+    "@platformatic/wattpm-pprof-capture": "^3.18.0",
     "avvio": "^9.1.0",
     "chalk": "^4.1.2",
     "commist": "^3.2.0",

package/plugins/alerts.js

@@ -33,7 +33,7 @@ async function alerts (app, _opts) {
       return
     }
 
-    runtime.on('application:worker:health', async (healthInfo) => {
+    const processHealthInfo = async (healthInfo) => {
       if (!healthInfo) {
         app.log.error('No health info received')
         return
@@ -120,7 +120,45 @@ async function alerts (app, _opts) {
           app.log.error({ err }, 'Failed to send a flamegraph')
         }
       }
-    })
+    }
+
+    if (app.watt.runtimeSupportsNewHealthMetrics()) {
+      // Runtime >= 3.18.0: Listen to health:metrics
+      runtime.on('application:worker:health:metrics', async (health) => {
+        if (!health) {
+          app.log.error('No health info received')
+          return
+        }
+
+        const {
+          id,
+          application: serviceId,
+          currentHealth
+        } = health
+
+        const { elu, heapUsed, heapTotal } = currentHealth
+        const healthConfig = app.watt.getHealthConfig()
+
+        const maxELU = healthConfig?.maxELU ?? 0.99
+        const maxHeapUsed = healthConfig?.maxHeapUsed ?? 0.99
+
+        const memoryUsage = heapUsed / heapTotal
+        const unhealthy = elu > maxELU || memoryUsage > maxHeapUsed
+
+        const healthInfo = {
+          id,
+          application: serviceId,
+          currentHealth,
+          unhealthy,
+          healthConfig: healthConfig || {}
+        }
+
+        await processHealthInfo(healthInfo)
+      })
+    } else {
+      // Runtime < 3.18.0:
+      runtime.on('application:worker:health', processHealthInfo)
+    }
   }
   app.setupAlerts = setupAlerts
 }

package/plugins/flamegraphs.js

@@ -18,19 +18,25 @@ async function flamegraphs (app, _opts) {
   const startProfilingOnWorker = async (runtime, workerFullId, logContext = {}) => {
     await sleep(gracePeriod)
 
+    const runtimeConfig = await runtime.getRuntimeConfig()
+    // Get application details to read service-level sourceMaps setting
+    const appDetails = await runtime.getApplicationDetails(workerFullId)
+    // Resolve sourceMaps: service-level overrides runtime-level (same logic as runtime.js:1440)
+    const sourceMaps = appDetails.config?.sourceMaps ?? runtimeConfig.sourceMaps
+
     try {
       // Start CPU profiling
       await runtime.sendCommandToApplication(
         workerFullId,
         'startProfiling',
-        { durationMillis, eluThreshold, type: 'cpu' }
+        { durationMillis, eluThreshold, type: 'cpu', sourceMaps }
       )
 
       // Start HEAP profiling
       await runtime.sendCommandToApplication(
         workerFullId,
         'startProfiling',
-        { durationMillis, eluThreshold, type: 'heap' }
+        { durationMillis, eluThreshold, type: 'heap', sourceMaps }
       )
     } catch (err) {
       app.log.error({ err, ...logContext }, 'Failed to start profiling')

package/test/alerts.test.js

@@ -11,6 +11,39 @@ import { start } from '../index.js'
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
+function emitHealthEvent (app, healthInfo) {
+  if (app.watt.runtimeSupportsNewHealthMetrics()) {
+    if (!healthInfo) {
+      // Emit null for testing error handling
+      app.watt.runtime.emit('application:worker:health:metrics', null)
+      return
+    }
+    // Runtime >= 3.18.0: emit health:metrics event with real event shape
+    const { id, application, currentHealth } = healthInfo
+
+    // Add currentELU to match real event shape
+    const enrichedCurrentHealth = {
+      ...currentHealth,
+      currentELU: {
+        idle: 1000,
+        active: currentHealth.elu * 1000,
+        utilization: currentHealth.elu
+      }
+    }
+
+    app.watt.runtime.emit('application:worker:health:metrics', {
+      id,
+      application,
+      worker: 0,
+      currentHealth: enrichedCurrentHealth,
+      healthSignals: []
+    })
+  } else {
+    // Runtime < 3.18.0: emit health event with full healthInfo
+    app.watt.runtime.emit('application:worker:health', healthInfo)
+  }
+}
+
 test('should send alert when service becomes unhealthy', async (t) => {
   const applicationName = 'test-app'
   const applicationId = randomUUID()
@@ -65,7 +98,7 @@ test('should send alert when service becomes unhealthy', async (t) => {
     id: 'main:0',
     application: 'main',
     currentHealth: {
-      elu: 0.95,
+      elu: 0.995,
       heapUsed: 76798040,
       heapTotal: 99721216
     },
@@ -81,15 +114,20 @@ test('should send alert when service becomes unhealthy', async (t) => {
     }
   }
 
-  app.watt.runtime.emit('application:worker:health', healthInfo)
+  emitHealthEvent(app, healthInfo)
 
   await sleep(200)
 
   assert.ok(alertReceived, 'Alert should have been received')
   assert.strictEqual(alertReceived.applicationId, applicationId)
-  assert.deepStrictEqual(alertReceived.alert, healthInfo)
+  assert.strictEqual(alertReceived.alert.id, healthInfo.id)
   assert.strictEqual(alertReceived.alert.application, 'main')
   assert.strictEqual(alertReceived.alert.service, 'main')
+  assert.strictEqual(alertReceived.alert.unhealthy, true)
+  assert.strictEqual(alertReceived.alert.currentHealth.elu, healthInfo.currentHealth.elu)
+  assert.strictEqual(alertReceived.alert.currentHealth.heapUsed, healthInfo.currentHealth.heapUsed)
+  assert.strictEqual(alertReceived.alert.currentHealth.heapTotal, healthInfo.currentHealth.heapTotal)
+  assert.strictEqual(alertReceived.alert.healthConfig, undefined, 'healthConfig should be deleted from alert')
   assert.ok(Array.isArray(alertReceived.healthHistory), 'Health history should be an array')
   assert.ok(alertReceived.healthHistory.length > 0, 'Health history should not be empty')
   assert.strictEqual(alertReceived.healthHistory[0].application, 'main')
@@ -158,7 +196,7 @@ test('should not send alert when application is healthy', async (t) => {
     }
   }
 
-  app.watt.runtime.emit('application:worker:health', healthInfo)
+  emitHealthEvent(app, healthInfo)
 
   await sleep(200)
 
@@ -225,7 +263,7 @@ test('should cache health data and include it in alerts', async (t) => {
       }
     }
 
-    app.watt.runtime.emit('application:worker:health', healthyInfo)
+    emitHealthEvent(app, healthyInfo)
     await sleep(100) // Small delay between events
   }
 
@@ -234,7 +272,7 @@ test('should cache health data and include it in alerts', async (t) => {
     id: 'service-1',
     application: 'service-1',
     currentHealth: {
-      elu: 0.95,
+      elu: 0.995,
       heapUsed: 76798040,
       heapTotal: 99721216
     },
@@ -250,7 +288,7 @@ test('should cache health data and include it in alerts', async (t) => {
     }
   }
 
-  app.watt.runtime.emit('application:worker:health', unhealthyInfo)
+  emitHealthEvent(app, unhealthyInfo)
   await sleep(200)
 
   assert.ok(alertReceived, 'Alert should have been received')
@@ -319,7 +357,7 @@ test('should not fail when health info is missing', async (t) => {
     await icc.close()
   })
 
-  app.watt.runtime.emit('application:worker:health', null)
+  emitHealthEvent(app, null)
 
   await sleep(200)
 
@@ -373,7 +411,7 @@ test('should respect alert retention window', async (t) => {
     id: applicationId,
     application: applicationId,
     currentHealth: {
-      elu: unhealthy ? 0.95 : 0.5,
+      elu: unhealthy ? 0.995 : 0.5,
       heapUsed: 76798040,
       heapTotal: 99721216
     },
@@ -390,15 +428,15 @@ test('should respect alert retention window', async (t) => {
   })
 
   // Send first unhealthy event - should trigger alert
-  app.watt.runtime.emit('application:worker:health', createHealthInfo('service-1', true))
+  emitHealthEvent(app, createHealthInfo('service-1', true))
   await sleep(50)
 
   // Send second unhealthy event immediately - should trigger alert
-  app.watt.runtime.emit('application:worker:health', createHealthInfo('service-2', true))
+  emitHealthEvent(app, createHealthInfo('service-2', true))
   await sleep(50)
 
   // Send second unhealthy event immediately - should be ignored due to retention window
-  app.watt.runtime.emit('application:worker:health', createHealthInfo('service-1', true))
+  emitHealthEvent(app, createHealthInfo('service-1', true))
   await sleep(100)
 
   assert.strictEqual(alertsReceived.length, 2, 'Only one alert should be sent within retention window')
@@ -406,7 +444,7 @@ test('should respect alert retention window', async (t) => {
   await sleep(500)
 
   // Send third unhealthy event - should trigger second alert
-  app.watt.runtime.emit('application:worker:health', createHealthInfo('service-1', true))
+  emitHealthEvent(app, createHealthInfo('service-1', true))
   await sleep(100)
 
   assert.strictEqual(alertsReceived.length, 3, 'Second alert should be sent after retention window expires')
@@ -497,7 +535,7 @@ test('should send alert when flamegraphs are disabled', async (t) => {
     id: 'main:0',
     application: 'main',
     currentHealth: {
-      elu: 0.95,
+      elu: 0.995,
       heapUsed: 76798040,
       heapTotal: 99721216
     },
@@ -513,15 +551,20 @@ test('should send alert when flamegraphs are disabled', async (t) => {
     }
   }
 
-  app.watt.runtime.emit('application:worker:health', healthInfo)
+  emitHealthEvent(app, healthInfo)
 
   await sleep(200)
 
   assert.ok(alertReceived, 'Alert should have been received')
   assert.strictEqual(alertReceived.applicationId, applicationId)
-  assert.deepStrictEqual(alertReceived.alert, healthInfo)
+  assert.strictEqual(alertReceived.alert.id, healthInfo.id)
   assert.strictEqual(alertReceived.alert.application, 'main')
   assert.strictEqual(alertReceived.alert.service, 'main')
+  assert.strictEqual(alertReceived.alert.unhealthy, true)
+  assert.strictEqual(alertReceived.alert.currentHealth.elu, healthInfo.currentHealth.elu)
+  assert.strictEqual(alertReceived.alert.currentHealth.heapUsed, healthInfo.currentHealth.heapUsed)
+  assert.strictEqual(alertReceived.alert.currentHealth.heapTotal, healthInfo.currentHealth.heapTotal)
+  assert.strictEqual(alertReceived.alert.healthConfig, undefined, 'healthConfig should be deleted from alert')
   assert.ok(Array.isArray(alertReceived.healthHistory), 'Health history should be an array')
   assert.ok(alertReceived.healthHistory.length > 0, 'Health history should not be empty')
   assert.strictEqual(alertReceived.healthHistory[0].application, 'main')
@@ -577,7 +620,7 @@ test('should send alert when failed to send a flamegraph', async (t) => {
     id: 'main:0',
     application: 'main',
     currentHealth: {
-      elu: 0.95,
+      elu: 0.995,
       heapUsed: 76798040,
       heapTotal: 99721216
     },
@@ -593,18 +636,107 @@ test('should send alert when failed to send a flamegraph', async (t) => {
     }
   }
 
-  app.watt.runtime.emit('application:worker:health', healthInfo)
+  emitHealthEvent(app, healthInfo)
 
   await sleep(200)
 
   assert.ok(alertReceived, 'Alert should have been received')
   assert.strictEqual(alertReceived.applicationId, applicationId)
-  assert.deepStrictEqual(alertReceived.alert, healthInfo)
+  assert.strictEqual(alertReceived.alert.id, healthInfo.id)
   assert.strictEqual(alertReceived.alert.application, 'main')
   assert.strictEqual(alertReceived.alert.service, 'main')
+  assert.strictEqual(alertReceived.alert.unhealthy, true)
+  assert.strictEqual(alertReceived.alert.currentHealth.elu, healthInfo.currentHealth.elu)
+  assert.strictEqual(alertReceived.alert.currentHealth.heapUsed, healthInfo.currentHealth.heapUsed)
+  assert.strictEqual(alertReceived.alert.currentHealth.heapTotal, healthInfo.currentHealth.heapTotal)
+  assert.strictEqual(alertReceived.alert.healthConfig, undefined, 'healthConfig should be deleted from alert')
   assert.ok(Array.isArray(alertReceived.healthHistory), 'Health history should be an array')
   assert.ok(alertReceived.healthHistory.length > 0, 'Health history should not be empty')
   assert.strictEqual(alertReceived.healthHistory[0].application, 'main')
   assert.strictEqual(alertReceived.healthHistory[0].service, 'main')
   assert.equal(alertReceived.flamegraph, null, 'Flamegraph should be null')
 })
+
+test('should handle old runtime (< 3.18.0) health events', async (t) => {
+  const applicationName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'service-1')
+
+  let alertReceived = null
+
+  const getAuthorizationHeader = async (headers) => {
+    return { ...headers, authorization: 'Bearer test-token' }
+  }
+
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName,
+    processAlerts: (req) => {
+      const alert = req.body
+      assert.equal(req.headers.authorization, 'Bearer test-token')
+      alertReceived = alert
+      return { id: 'test-alert-id', ...alert }
+    }
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000'
+  })
+
+  const app = await start()
+  app.getAuthorizationHeader = getAuthorizationHeader
+
+  // Mock the runtime version check to simulate old runtime
+  const originalFn = app.watt.runtimeSupportsNewHealthMetrics
+  app.watt.runtimeSupportsNewHealthMetrics = () => false
+
+  // Remove all existing event listeners
+  app.watt.runtime.removeAllListeners('application:worker:health:metrics')
+  app.watt.runtime.removeAllListeners('application:worker:health')
+
+  // Re-setup alerts with the mocked function (will use old path)
+  await app.setupAlerts()
+
+  t.after(async () => {
+    app.watt.runtimeSupportsNewHealthMetrics = originalFn
+    await app.close()
+    await icc.close()
+  })
+
+  // Manually trigger health event with unhealthy state using old event format
+  const healthInfo = {
+    id: 'main:0',
+    application: 'main',
+    currentHealth: {
+      elu: 0.995,
+      heapUsed: 76798040,
+      heapTotal: 99721216
+    },
+    unhealthy: true,
+    healthConfig: {
+      enabled: true,
+      interval: 1000,
+      gracePeriod: 1000,
+      maxUnhealthyChecks: 10,
+      maxELU: 0.99,
+      maxHeapUsed: 0.99,
+      maxHeapTotal: 4294967296
+    }
+  }
+
+  // Emit using old event format (application:worker:health)
+  app.watt.runtime.emit('application:worker:health', healthInfo)
+
+  await sleep(200)
+
+  assert.ok(alertReceived, 'Alert should have been received')
+  assert.strictEqual(alertReceived.applicationId, applicationId)
+  assert.strictEqual(alertReceived.alert.id, healthInfo.id)
+  assert.strictEqual(alertReceived.alert.application, 'main')
+  assert.strictEqual(alertReceived.alert.service, 'main')
+  assert.strictEqual(alertReceived.alert.unhealthy, true)
+  assert.deepStrictEqual(alertReceived.alert.currentHealth, healthInfo.currentHealth)
+  assert.strictEqual(alertReceived.alert.healthConfig, undefined, 'healthConfig should be deleted from alert')
+})

package/test/fixtures/runtime-health-custom/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "runtime-health",
+  "workspaces": [
+    "services/*"
+  ],
+  "scripts": {
+    "start": "platformatic start"
+  },
+  "devDependencies": {
+    "fastify": "^5.0.0",
+    "borp": "^0.19.0"
+  },
+  "dependencies": {
+    "@platformatic/runtime": "workspace:*",
+    "platformatic": "workspace:*"
+  },
+  "engines": {
+    "node": "^18.8.0 || >=20.6.0"
+  }
+}

package/test/fixtures/runtime-health-custom/platformatic.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://schemas.platformatic.dev/@platformatic/runtime/2.62.1.json",
+  "entrypoint": "service-1",
+  "watch": true,
+  "autoload": {
+    "path": "services",
+    "exclude": ["docs"]
+  },
+  "logger": {
+    "level": "info"
+  },
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": "3042"
+  },
+  "health": {
+    "enabled": true,
+    "interval": 2500,
+    "maxUnhealthyChecks": 50
+  }
+}

package/test/fixtures/runtime-health-custom/services/service-1/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "service-1",
+  "scripts": {
+    "start": "platformatic start",
+    "test": "borp"
+  },
+  "devDependencies": {
+    "fastify": "^5.0.0",
+    "borp": "^0.19.0"
+  },
+  "dependencies": {
+    "@platformatic/service": "^2.70.0"
+  },
+  "engines": {
+    "node": "^18.8.0 || >=20.6.0"
+  }
+}

package/test/fixtures/runtime-health-custom/services/service-1/platformatic.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://schemas.platformatic.dev/@platformatic/service/2.62.1.json",
+  "service": {
+    "openapi": true
+  },
+  "watch": true,
+  "plugins": {
+    "paths": [
+      {
+        "path": "./plugins",
+        "encapsulate": false
+      },
+      "./routes"
+    ]
+  }
+}

package/test/fixtures/runtime-health-custom/services/service-1/plugins/example.js

@@ -0,0 +1,6 @@
+/// <reference path="../global.d.ts" />
+'use strict'
+/** @param {import('fastify').FastifyInstance} fastify */
+module.exports = async function (fastify, opts) {
+  fastify.decorate('example', 'foobar')
+}

package/test/fixtures/runtime-health-custom/services/service-1/routes/root.cjs

@@ -0,0 +1,8 @@
+/// <reference path="../global.d.ts" />
+'use strict'
+/** @param {import('fastify').FastifyInstance} fastify */
+module.exports = async function (fastify, opts) {
+  fastify.get('/example', async (request, reply) => {
+    return { hello: fastify.example }
+  })
+}

package/test/fixtures/runtime-health-custom/services/service-2/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "service-2",
+  "scripts": {
+    "start": "platformatic start",
+    "test": "borp"
+  },
+  "devDependencies": {
+    "fastify": "^5.0.0",
+    "borp": "^0.19.0"
+  },
+  "dependencies": {
+    "@platformatic/service": "^2.70.0"
+  },
+  "engines": {
+    "node": "^18.8.0 || >=20.6.0"
+  }
+}

package/test/fixtures/runtime-health-custom/services/service-2/platformatic.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://schemas.platformatic.dev/@platformatic/service/2.62.1.json",
+  "service": {
+    "openapi": true
+  },
+  "watch": true,
+  "plugins": {
+    "paths": [
+      {
+        "path": "./plugins",
+        "encapsulate": false
+      },
+      "./routes"
+    ]
+  }
+}

package/test/fixtures/runtime-health-custom/services/service-2/plugins/example.js

@@ -0,0 +1,6 @@
+/// <reference path="../global.d.ts" />
+'use strict'
+/** @param {import('fastify').FastifyInstance} fastify */
+module.exports = async function (fastify, opts) {
+  fastify.decorate('example', 'foobar')
+}

package/test/fixtures/runtime-health-custom/services/service-2/routes/root.cjs

@@ -0,0 +1,8 @@
+/// <reference path="../global.d.ts" />
+'use strict'
+/** @param {import('fastify').FastifyInstance} fastify */
+module.exports = async function (fastify, opts) {
+  fastify.get('/example', async (request, reply) => {
+    return { hello: fastify.example }
+  })
+}

package/test/fixtures/runtime-health-disabled/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "runtime-health",
+  "workspaces": [
+    "services/*"
+  ],
+  "scripts": {
+    "start": "platformatic start"
+  },
+  "devDependencies": {
+    "fastify": "^5.0.0",
+    "borp": "^0.19.0"
+  },
+  "dependencies": {
+    "@platformatic/runtime": "workspace:*",
+    "platformatic": "workspace:*"
+  },
+  "engines": {
+    "node": "^18.8.0 || >=20.6.0"
+  }
+}