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

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

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

package/test/fixtures/runtime-health-disabled/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-disabled/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-disabled/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-disabled/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-disabled/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-disabled/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-disabled/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-disabled/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/health.test.js

@@ -3,6 +3,7 @@ import { test } from 'node:test'
 import { randomUUID } from 'node:crypto'
 import { join, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { setTimeout } from 'node:timers/promises'
 
 import {
   setUpEnvironment,
@@ -37,8 +38,90 @@ test('check that health is configured in runtime', async (t) => {
 
   const runtimeConfig = await app.watt.runtime.getRuntimeConfig()
 
+  // Runtime applies its own defaults on top of ours, so we just verify health is enabled
+  // and has expected properties
   assert.ok(runtimeConfig.health, 'Health configuration should be present')
   assert.strictEqual(runtimeConfig.health.enabled, true, 'Health monitoring should be enabled')
-  assert.strictEqual(runtimeConfig.health.interval, 1000)
-  assert.strictEqual(runtimeConfig.health.gracePeriod, 30000)
+  assert.ok(runtimeConfig.health.interval, 'Health interval should be set')
+  assert.ok(runtimeConfig.health.maxUnhealthyChecks, 'Health maxUnhealthyChecks should be set')
+})
+
+test('check that custom health configuration is not overridden', async (t) => {
+  const appName = 'test-health-custom'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-health-custom')
+
+  const icc = await startICC(t, {
+    applicationId
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: appName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000'
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  const runtimeConfig = await app.watt.runtime.getRuntimeConfig()
+
+  assert.ok(runtimeConfig.health, 'Health configuration should be present')
+  assert.strictEqual(runtimeConfig.health.enabled, true, 'Health monitoring should be enabled')
+  assert.strictEqual(runtimeConfig.health.interval, 2500, 'Custom interval should be preserved')
+  assert.strictEqual(runtimeConfig.health.maxUnhealthyChecks, 50, 'Custom maxUnhealthyChecks should be preserved')
+})
+
+test('should force health enabled and set defaults when app tries to disable it', async (t) => {
+  const appName = 'test-health-disabled'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-health-disabled')
+
+  const icc = await startICC(t, {
+    applicationId
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: appName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000'
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  const runtimeConfig = await app.watt.runtime.getRuntimeConfig()
+
+  assert.ok(runtimeConfig.health, 'Health configuration should be present')
+  assert.strictEqual(runtimeConfig.health.enabled, true, 'Health should be forced to enabled even if app config says false')
+  assert.ok(runtimeConfig.health.interval, 'Health interval should be set')
+  assert.ok(runtimeConfig.health.maxUnhealthyChecks, 'Health maxUnhealthyChecks should be set')
+
+  // Wait for health events
+  let healthEventReceived = false
+  const eventName = app.watt.runtimeSupportsNewHealthMetrics()
+    ? 'application:worker:health:metrics'
+    : 'application:worker:health'
+
+  app.watt.runtime.on(eventName, (healthInfo) => {
+    healthEventReceived = true
+  })
+
+  // Wait up to 5 seconds for a health event
+  const startTime = Date.now()
+  /* eslint-disable no-unmodified-loop-condition */
+  while (!healthEventReceived && (Date.now() - startTime) < 5000) {
+    await setTimeout(100)
+  }
+  /* eslint-enable no-unmodified-loop-condition */
+
+  assert.ok(healthEventReceived, 'Should receive health events since enabled is forced to true')
 })

package/test/patch-config.test.js

@@ -151,9 +151,13 @@ test('should configure health options', async (t) => {
   const runtimeConfig = await app.watt.runtime.getRuntimeConfig(true)
 
   const { health } = runtimeConfig
+  // Runtime applies its own defaults on top of ours, so we just verify health is configured
   assert.strictEqual(health.enabled, true)
-  assert.strictEqual(health.interval, 1000)
-  assert.strictEqual(health.maxUnhealthyChecks, 30)
+  assert.ok(health.interval, 'Health interval should be set')
+  assert.strictEqual(health.maxUnhealthyChecks, 10, 'Health maxUnhealthyChecks should have default value')
+  assert.strictEqual(health.maxELU, 0.99, 'Health maxELU should have default value')
+  assert.strictEqual(health.maxHeapUsed, 0.99, 'Health maxHeapUsed should have default value')
+  assert.strictEqual(health.gracePeriod, 30000, 'Health gracePeriod should have default value')
 })
 
 test('should not set opentelemetry if it is disabled', async (t) => {
@@ -214,3 +218,114 @@ test('should not set opentelemetry if it is disabled', async (t) => {
   const mainConfig = await body.json()
   assert.deepStrictEqual(mainConfig.telemetry, expectedTelemetry)
 })
+test('should expose runtimeSupportsNewHealthMetrics method', async (t) => {
+  const applicationName = 'test-application'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'service-1')
+
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000'
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  assert.strictEqual(typeof app.watt.runtimeSupportsNewHealthMetrics, 'function', 'runtimeSupportsNewHealthMetrics should be a function')
+
+  const supportsNewMetrics = app.watt.runtimeSupportsNewHealthMetrics()
+  assert.strictEqual(typeof supportsNewMetrics, 'boolean', 'runtimeSupportsNewHealthMetrics should return a boolean')
+
+  const runtimeVersion = app.watt.getRuntimeVersion()
+  assert.ok(runtimeVersion, 'Runtime version should be available')
+})
+
+test('should expose getHealthConfig method', async (t) => {
+  const applicationName = 'test-application'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'service-1')
+
+  const icc = await startICC(t, {
+    applicationId,
+    applicationName
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: applicationName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000'
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  assert.strictEqual(typeof app.watt.getHealthConfig, 'function', 'getHealthConfig should be a function')
+
+  const healthConfig = app.watt.getHealthConfig()
+  assert.ok(healthConfig, 'Health config should be returned')
+  assert.strictEqual(typeof healthConfig, 'object', 'Health config should be an object')
+  assert.strictEqual(healthConfig.enabled, true, 'Health should be enabled')
+  assert.ok(healthConfig.interval, 'Health config should have interval')
+  assert.strictEqual(healthConfig.maxUnhealthyChecks, 10, 'Health config should have maxUnhealthyChecks default')
+  assert.strictEqual(healthConfig.maxELU, 0.99, 'Health config should have maxELU default')
+  assert.strictEqual(healthConfig.maxHeapUsed, 0.99, 'Health config should have maxHeapUsed default')
+  assert.strictEqual(healthConfig.gracePeriod, 30000, 'Health config should have gracePeriod default')
+})
+
+test('should configure health based on runtime version', async (t) => {
+  const appName = 'test-app'
+  const applicationId = randomUUID()
+  const applicationPath = join(__dirname, 'fixtures', 'runtime-service')
+
+  await installDeps(t, applicationPath)
+
+  const icc = await startICC(t, {
+    applicationId
+  })
+
+  setUpEnvironment({
+    PLT_APP_NAME: appName,
+    PLT_APP_DIR: applicationPath,
+    PLT_ICC_URL: 'http://127.0.0.1:3000'
+  })
+
+  const app = await start()
+
+  t.after(async () => {
+    await app.close()
+    await icc.close()
+  })
+
+  const runtimeConfig = app.watt.runtime.getRuntimeConfig(true)
+  const { health } = runtimeConfig
+
+  // Health should always be enabled regardless of runtime version
+  assert.strictEqual(health.enabled, true, 'Health should be enabled')
+
+  const supportsNewMetrics = app.watt.runtimeSupportsNewHealthMetrics()
+
+  if (supportsNewMetrics) {
+    // For new runtime (>= 3.18.0), we only force enabled: true
+    // Other values come from app config or runtime defaults
+    assert.ok(health.interval, 'Health interval should be set')
+    assert.ok(health.maxUnhealthyChecks, 'Health maxUnhealthyChecks should be set')
+  } else {
+    // For old runtime (< 3.18.0), we set specific defaults
+    assert.ok(health.interval, 'Health interval should be set')
+    assert.ok(health.maxUnhealthyChecks, 'Health maxUnhealthyChecks should be set')
+  }
+})