@platformatic/runtime 3.17.0 → 3.19.0

package/config.d.ts

@@ -306,6 +306,7 @@ export type PlatformaticRuntimeConfig = {
                 body?: string;
               };
             };
+        healthChecksTimeouts?: number | string;
         plugins?: string[];
         timeout?: number | string;
         /**

package/lib/errors.js

@@ -128,10 +128,6 @@ export const MissingPprofCapture = createError(
   'Please install @platformatic/wattpm-pprof-capture'
 )
 
-export const GetHeapStatisticUnavailable = createError(
-  `${ERROR_PREFIX}_GET_HEAP_STATISTIC_UNAVAILABLE`,
-  'The getHeapStatistics method is not available in your Node version'
-)
 export const FailedToSendHealthSignalsError = createError(
   `${ERROR_PREFIX}_FAILED_TO_SEND_HEALTH_SIGNALS`,
   'Cannot send health signals from application "%s": %s'

package/lib/management-api.js

@@ -238,6 +238,7 @@ export async function managementApiPlugin (app, opts) {
     return metrics
   })
 
+  // TODO: Remove in next major version - deprecated endpoint
   app.get('/metrics/live', { websocket: true }, async socket => {
     const config = await runtime.getRuntimeConfig()
 
@@ -256,26 +257,32 @@ export async function managementApiPlugin (app, opts) {
       return
     }
 
-    const cachedMetrics = runtime.getCachedMetrics()
-    if (cachedMetrics.length > 0) {
-      const serializedMetrics = cachedMetrics.map(metric => JSON.stringify(metric)).join('\n')
-      socket.send(serializedMetrics + '\n')
+    const pollAndSendMetrics = async () => {
+      try {
+        const metrics = await runtime.getFormattedMetrics()
+        if (metrics) {
+          const serializedMetrics = JSON.stringify(metrics)
+          socket.send(serializedMetrics + '\n')
+        }
+      } catch (error) {
+        // If there's an error, stop polling and close the connection
+        clearInterval(pollingInterval)
+        socket.close()
+      }
     }
 
-    const eventHandler = metrics => {
-      const serializedMetrics = JSON.stringify(metrics)
-      socket.send(serializedMetrics + '\n')
-    }
+    // Poll every second
+    const pollingInterval = setInterval(pollAndSendMetrics, 1000)
 
-    runtime.on('metrics', eventHandler)
+    // Send initial metrics immediately
+    await pollAndSendMetrics()
 
-    socket.on('error', () => {
-      runtime.off('metrics', eventHandler)
-    })
+    const cleanup = () => {
+      clearInterval(pollingInterval)
+    }
 
-    socket.on('close', () => {
-      runtime.off('metrics', eventHandler)
-    })
+    socket.on('error', cleanup)
+    socket.on('close', cleanup)
   })
 
   app.get('/logs/live', { websocket: true }, async socket => {

package/lib/prom-server.js

@@ -68,7 +68,7 @@ async function checkLiveness (runtime) {
       return check
     } else if (typeof check === 'object') {
       response = check
-      return check.status
+      return check.status || false
     }
     return false
   })
@@ -85,7 +85,7 @@ export async function startPrometheusServer (runtime, opts) {
   const metricsEndpoint = opts.endpoint ?? DEFAULT_METRICS_ENDPOINT
   const auth = opts.auth ?? null
 
-  const promServer = fastify({ name: 'Prometheus server' })
+  const promServer = fastify({ name: 'Prometheus server', loggerInstance: runtime.logger })
   promServer.register(fastifyAccepts)
 
   let onRequestHook
@@ -151,7 +151,7 @@ export async function startPrometheusServer (runtime, opts) {
       url: readinessEndpoint,
       method: 'GET',
       logLevel: 'warn',
-      handler: async (req, reply) => {
+      handler: async (_req, reply) => {
         reply.type('text/plain')
 
         const { status, response } = await checkReadiness(runtime)
@@ -190,7 +190,7 @@ export async function startPrometheusServer (runtime, opts) {
       url: livenessEndpoint,
       method: 'GET',
       logLevel: 'warn',
-      handler: async (req, reply) => {
+      handler: async (_req, reply) => {
         reply.type('text/plain')
 
         const { status, response, readiness } = await checkLiveness(runtime)

package/lib/runtime.js

@@ -31,13 +31,11 @@ import {
   ApplicationNotStartedError,
   ApplicationStartTimeoutError,
   CannotRemoveEntrypointError,
-  GetHeapStatisticUnavailable,
   InvalidArgumentError,
   MessagingError,
   MissingEntrypointError,
   MissingPprofCapture,
   RuntimeAbortedError,
-  RuntimeExitedError,
   WorkerNotFoundError
 } from './errors.js'
 import { abstractLogger, createLogger } from './logger.js'
@@ -48,14 +46,13 @@ import { startScheduler } from './scheduler.js'
 import { createSharedStore } from './shared-http-cache.js'
 import { version } from './version.js'
 import { HealthSignalsQueue } from './worker/health-signals.js'
-import { sendViaITC, waitEventFromITC } from './worker/itc.js'
+import { sendMultipleViaITC, sendViaITC, waitEventFromITC } from './worker/itc.js'
 import { RoundRobinMap } from './worker/round-robin-map.js'
 import {
   kApplicationId,
   kConfig,
   kFullId,
   kHealthCheckTimer,
-  kHealthMetricsTimer,
   kId,
   kITC,
   kLastHealthCheckELU,
@@ -71,8 +68,6 @@ const kWorkerFile = join(import.meta.dirname, 'worker/main.js')
 const kInspectorOptions = Symbol('plt.runtime.worker.inspectorOptions')
 
 const MAX_LISTENERS_COUNT = 100
-const MAX_METRICS_QUEUE_LENGTH = 5 * 60 // 5 minutes in seconds
-const COLLECT_METRICS_TIMEOUT = 1000
 
 const MAX_CONCURRENCY = 5
 const MAX_BOOTSTRAP_ATTEMPTS = 5
@@ -98,8 +93,7 @@ export class Runtime extends EventEmitter {
   #entrypointId
   #url
 
-  #metrics
-  #metricsTimeout
+  #healthMetricsTimer
 
   #meshInterceptor
   #dispatcher
@@ -283,9 +277,8 @@ export class Runtime extends EventEmitter {
 
     this.#updateStatus('started')
 
-    if (this.#config.metrics?.enabled !== false && typeof this.#metrics === 'undefined') {
-      this.startCollectingMetrics()
-    }
+    // Start the global health metrics timer for all workers if needed
+    this.#startHealthMetricsCollectionIfNeeded()
 
     await this.#dynamicWorkersScaler?.start()
     this.#showUrl()
@@ -339,7 +332,7 @@ export class Runtime extends EventEmitter {
   }
 
   async close (silent = false) {
-    clearInterval(this.#metricsTimeout)
+    clearTimeout(this.#healthMetricsTimer)
 
     await this.stop(silent)
     this.#updateStatus('closing')
@@ -703,29 +696,15 @@ export class Runtime extends EventEmitter {
     }
   }
 
+  // TODO: Remove in next major version
   startCollectingMetrics () {
-    this.#metrics = []
-    this.#metricsTimeout = setInterval(async () => {
-      if (this.#status !== 'started') {
-        return
-      }
-
-      let metrics = null
-      try {
-        metrics = await this.getFormattedMetrics()
-      } catch (error) {
-        if (!(error instanceof RuntimeExitedError)) {
-          this.logger.error({ err: ensureLoggableError(error) }, 'Error collecting metrics')
-        }
-        return
-      }
+    this.logger.warn('startCollectingMetrics() is deprecated and no longer collects metrics. Metrics are now polled on-demand by the management API.')
+  }
 
-      this.emitAndNotify('metrics', metrics)
-      this.#metrics.push(metrics)
-      if (this.#metrics.length > MAX_METRICS_QUEUE_LENGTH) {
-        this.#metrics.shift()
-      }
-    }, COLLECT_METRICS_TIMEOUT).unref()
+  // TODO: Remove in next major version
+  getCachedMetrics () {
+    this.logger.warn('getCachedMetrics() is deprecated and returns an empty array. Metrics are no longer cached.')
+    return []
   }
 
   invalidateHttpCache (options = {}) {
@@ -966,31 +945,45 @@ export class Runtime extends EventEmitter {
   }
 
   async getCustomHealthChecks () {
-    const status = {}
+    const invocations = []
 
     for (const id of this.#applications.keys()) {
       const workersIds = this.#workers.getKeys(id)
       for (const workerId of workersIds) {
-        const worker = this.#workers.get(workerId)
-        status[workerId] = await sendViaITC(worker, 'getCustomHealthCheck')
+        invocations.push([workerId, this.#workers.get(workerId)])
       }
     }
 
-    return status
+    return sendMultipleViaITC(
+      invocations,
+      'getCustomHealthCheck',
+      undefined,
+      [],
+      this.#concurrency,
+      this.#config.metrics.healthChecksTimeout,
+      {}
+    )
   }
 
   async getCustomReadinessChecks () {
-    const status = {}
+    const invocations = []
 
     for (const id of this.#applications.keys()) {
       const workersIds = this.#workers.getKeys(id)
       for (const workerId of workersIds) {
-        const worker = this.#workers.get(workerId)
-        status[workerId] = await sendViaITC(worker, 'getCustomReadinessCheck')
+        invocations.push([workerId, this.#workers.get(workerId)])
       }
     }
 
-    return status
+    return sendMultipleViaITC(
+      invocations,
+      'getCustomReadinessCheck',
+      undefined,
+      [],
+      this.#concurrency,
+      this.#config.metrics.healthChecksTimeout,
+      {}
+    )
   }
 
   async getMetrics (format = 'json') {
@@ -1036,10 +1029,6 @@ export class Runtime extends EventEmitter {
     return { metrics }
   }
 
-  getCachedMetrics () {
-    return this.#metrics
-  }
-
   async getFormattedMetrics () {
     try {
       const { metrics } = await this.getMetrics()
@@ -1280,10 +1269,6 @@ export class Runtime extends EventEmitter {
   }
 
   async getWorkerHealth (worker, options = {}) {
-    if (!features.node.worker.getHeapStatistics) {
-      throw new GetHeapStatisticUnavailable()
-    }
-
     const currentELU = worker.performance.eventLoopUtilization()
     const previousELU = options.previousELU
 
@@ -1292,6 +1277,10 @@ export class Runtime extends EventEmitter {
       elu = worker.performance.eventLoopUtilization(elu, previousELU)
     }
 
+    if (!features.node.worker.getHeapStatistics) {
+      return { elu: elu.utilization, currentELU }
+    }
+
     const { used_heap_size: heapUsed, total_heap_size: heapTotal } = await worker.getHeapStatistics()
     return { elu: elu.utilization, heapUsed, heapTotal, currentELU }
   }
@@ -1460,17 +1449,26 @@ export class Runtime extends EventEmitter {
       workerEnv.NODE_OPTIONS = `${originalNodeOptions} ${applicationConfig.nodeOptions}`.trim()
     }
 
-    const maxHeapTotal =
-      typeof health.maxHeapTotal === 'string' ? parseMemorySize(health.maxHeapTotal) : health.maxHeapTotal
-    const maxYoungGeneration =
-      typeof health.maxYoungGeneration === 'string'
-        ? parseMemorySize(health.maxYoungGeneration)
-        : health.maxYoungGeneration
+    let resourceLimits
 
-    const maxOldGenerationSizeMb = Math.floor(
-      (maxYoungGeneration > 0 ? maxHeapTotal - maxYoungGeneration : maxHeapTotal) / (1024 * 1024)
-    )
-    const maxYoungGenerationSizeMb = maxYoungGeneration ? Math.floor(maxYoungGeneration / (1024 * 1024)) : undefined
+    {
+      const maxHeapTotal =
+        typeof health.maxHeapTotal === 'string' ? parseMemorySize(health.maxHeapTotal) : health.maxHeapTotal
+      const maxYoungGeneration =
+        typeof health.maxYoungGeneration === 'string'
+          ? parseMemorySize(health.maxYoungGeneration)
+          : health.maxYoungGeneration
+
+      const maxOldGenerationSizeMb = maxHeapTotal ? Math.floor((maxYoungGeneration > 0 ? maxHeapTotal - maxYoungGeneration : maxHeapTotal) / (1024 * 1024)) : undefined
+      const maxYoungGenerationSizeMb = maxYoungGeneration ? Math.floor(maxYoungGeneration / (1024 * 1024)) : undefined
+
+      if (maxOldGenerationSizeMb || maxYoungGenerationSizeMb) {
+        resourceLimits = {
+          maxOldGenerationSizeMb,
+          maxYoungGenerationSizeMb
+        }
+      }
+    }
 
     const worker = new Worker(kWorkerFile, {
       workerData: {
@@ -1494,10 +1492,7 @@ export class Runtime extends EventEmitter {
       argv: applicationConfig.arguments,
       execArgv,
       env: workerEnv,
-      resourceLimits: {
-        maxOldGenerationSizeMb,
-        maxYoungGenerationSizeMb
-      },
+      resourceLimits,
       stdout: true,
       stderr: true
     })
@@ -1646,36 +1641,75 @@ export class Runtime extends EventEmitter {
     return worker
   }
 
-  #setupHealthMetrics (id, index, worker, errorLabel) {
-    // Clear the timeout when exiting
-    worker.on('exit', () => clearTimeout(worker[kHealthMetricsTimer]))
+  #startHealthMetricsCollectionIfNeeded () {
+    // Need health metrics if dynamic workers scaler exists (for vertical scaling)
+    // or if any worker has health checks enabled
+    let needsHealthMetrics = !!this.#dynamicWorkersScaler
 
-    worker[kHealthMetricsTimer] = setTimeout(async () => {
-      if (worker[kWorkerStatus] !== 'started') return
+    if (!needsHealthMetrics) {
+      // Check if any worker has health checks enabled
+      for (const worker of this.#workers.values()) {
+        const healthConfig = worker[kConfig]?.health
+        if (healthConfig?.enabled && this.#config.restartOnError > 0) {
+          needsHealthMetrics = true
+          break
+        }
+      }
+    }
 
-      let health = null
-      try {
-        health = await this.getWorkerHealth(worker, {
-          previousELU: worker[kLastHealthCheckELU]
-        })
-      } catch (err) {
-        this.logger.error({ err }, `Failed to get health for ${errorLabel}.`)
-      } finally {
-        worker[kLastHealthCheckELU] = health?.currentELU ?? null
+    if (needsHealthMetrics) {
+      this.#startHealthMetricsCollection()
+    }
+  }
+
+  #startHealthMetricsCollection () {
+    const collectHealthMetrics = async () => {
+      if (this.#status !== 'started') {
+        return
       }
 
-      const healthSignals = worker[kWorkerHealthSignals]?.getAll() ?? []
+      // Iterate through all workers and collect health metrics
+      for (const worker of this.#workers.values()) {
+        if (worker[kWorkerStatus] !== 'started') {
+          continue
+        }
 
-      this.emitAndNotify('application:worker:health:metrics', {
-        id: worker[kId],
-        application: id,
-        worker: index,
-        currentHealth: health,
-        healthSignals
-      })
+        const id = worker[kApplicationId]
+        const index = worker[kWorkerId]
+        const errorLabel = this.#workerExtendedLabel(id, index, worker[kConfig].workers)
 
-      worker[kHealthMetricsTimer].refresh()
-    }, 1000).unref()
+        let health = null
+        try {
+          health = await this.getWorkerHealth(worker, {
+            previousELU: worker[kLastHealthCheckELU]
+          })
+        } catch (err) {
+          this.logger.error({ err }, `Failed to get health for ${errorLabel}.`)
+        } finally {
+          worker[kLastHealthCheckELU] = health?.currentELU ?? null
+        }
+
+        const healthSignals = worker[kWorkerHealthSignals]?.getAll() ?? []
+
+        // We use emit instead of emitAndNotify to avoid sending a postMessages
+        // to each workers even if they are not interested in health metrics.
+        // No one of the known capabilities use this event yet.
+        this.emit('application:worker:health:metrics', {
+          id: worker[kId],
+          application: id,
+          worker: index,
+          currentHealth: health,
+          healthSignals
+        })
+      }
+
+      // Reschedule the next check. We are not using .refresh() because it's more
+      // expensive (weird).
+      this.#healthMetricsTimer = setTimeout(collectHealthMetrics, 1000).unref()
+    }
+
+    // Start the collection
+    this.#healthMetricsTimer = setTimeout(collectHealthMetrics, 1000).unref()
   }
 
   #setupHealthCheck (config, applicationConfig, workersCount, id, index, worker, errorLabel) {
@@ -1725,7 +1759,7 @@ export class Runtime extends EventEmitter {
         const memoryUsage = health.heapUsed / maxHeapTotal
         const unhealthy = health.elu > maxELU || memoryUsage > maxHeapUsed
 
-        this.emitAndNotify('application:worker:health', {
+        this.emit('application:worker:health', {
           id: worker[kId],
           application: id,
           worker: index,
@@ -1842,8 +1876,6 @@ export class Runtime extends EventEmitter {
         this.logger.info(`Started the ${label}...`)
       }
 
-      this.#setupHealthMetrics(id, index, worker, label)
-
       const { enabled, gracePeriod } = worker[kConfig].health
       if (enabled && config.restartOnError > 0) {
         // if gracePeriod is 0, it will be set to 1 to start health checks immediately

package/lib/worker/itc.js

@@ -1,4 +1,4 @@
-import { ensureLoggableError } from '@platformatic/foundation'
+import { ensureLoggableError, executeInParallel, executeWithTimeout, kTimeout } from '@platformatic/foundation'
 import { ITC } from '@platformatic/itc'
 import { Unpromise } from '@watchable/unpromise'
 import { once } from 'node:events'
@@ -65,6 +65,29 @@ export async function sendViaITC (worker, name, message, transferList) {
   return safeHandleInITC(worker, () => worker[kITC].send(name, message, { transferList }))
 }
 
+export async function sendMultipleViaITC (
+  idsAndWorkerPairs,
+  name,
+  message,
+  transferList,
+  concurrency,
+  timeout = 5000,
+  timeoutFallbackValue = kTimeout
+) {
+  const results = await executeInParallel(
+    async (id, worker) => {
+      return [
+        id,
+        await executeWithTimeout(sendViaITC(worker, name, message, transferList), timeout, timeoutFallbackValue)
+      ]
+    },
+    idsAndWorkerPairs,
+    concurrency
+  )
+
+  return Object.fromEntries(results)
+}
+
 export async function waitEventFromITC (worker, event) {
   return safeHandleInITC(worker, () => once(worker[kITC], event))
 }

package/lib/worker/symbols.js

@@ -5,7 +5,6 @@ export const kApplicationId = Symbol.for('plt.runtime.application.id')
 export const kWorkerId = Symbol.for('plt.runtime.worker.id')
 export const kITC = Symbol.for('plt.runtime.itc')
 export const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer')
-export const kHealthMetricsTimer = Symbol.for('plt.runtime.worker.healthMetricsTimer')
 export const kWorkerStatus = Symbol('plt.runtime.worker.status')
 export const kWorkerHealthSignals = Symbol.for('plt.runtime.worker.healthSignals')
 export const kWorkerStartTime = Symbol.for('plt.runtime.worker.startTime')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.17.0",
+  "version": "3.19.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -35,14 +35,14 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/db": "3.17.0",
-    "@platformatic/composer": "3.17.0",
-    "@platformatic/gateway": "3.17.0",
-    "@platformatic/node": "3.17.0",
-    "@platformatic/service": "3.17.0",
-    "@platformatic/sql-graphql": "3.17.0",
-    "@platformatic/sql-mapper": "3.17.0",
-    "@platformatic/wattpm-pprof-capture": "3.17.0"
+    "@platformatic/composer": "3.19.0",
+    "@platformatic/db": "3.19.0",
+    "@platformatic/gateway": "3.19.0",
+    "@platformatic/node": "3.19.0",
+    "@platformatic/service": "3.19.0",
+    "@platformatic/sql-mapper": "3.19.0",
+    "@platformatic/sql-graphql": "3.19.0",
+    "@platformatic/wattpm-pprof-capture": "3.19.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -71,12 +71,12 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.15.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.17.0",
-    "@platformatic/itc": "3.17.0",
-    "@platformatic/generators": "3.17.0",
-    "@platformatic/foundation": "3.17.0",
-    "@platformatic/metrics": "3.17.0",
-    "@platformatic/telemetry": "3.17.0"
+    "@platformatic/basic": "3.19.0",
+    "@platformatic/generators": "3.19.0",
+    "@platformatic/foundation": "3.19.0",
+    "@platformatic/telemetry": "3.19.0",
+    "@platformatic/itc": "3.19.0",
+    "@platformatic/metrics": "3.19.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.17.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.19.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -1626,8 +1626,7 @@
             {
               "type": "string"
             }
-          ],
-          "default": 4294967296
+          ]
         },
         "maxYoungGeneration": {
           "anyOf": [
@@ -1954,6 +1953,17 @@
                 }
               ]
             },
+            "healthChecksTimeouts": {
+              "anyOf": [
+                {
+                  "type": "integer"
+                },
+                {
+                  "type": "string"
+                }
+              ],
+              "default": 5000
+            },
             "plugins": {
               "type": "array",
               "items": {