@platformatic/runtime 3.17.0 → 3.18.0

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/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'
@@ -55,7 +53,6 @@ import {
   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 = {}) {
@@ -1036,10 +1015,6 @@ export class Runtime extends EventEmitter {
     return { metrics }
   }
 
-  getCachedMetrics () {
-    return this.#metrics
-  }
-
   async getFormattedMetrics () {
     try {
       const { metrics } = await this.getMetrics()
@@ -1280,10 +1255,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 +1263,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 +1435,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 +1478,7 @@ export class Runtime extends EventEmitter {
       argv: applicationConfig.arguments,
       execArgv,
       env: workerEnv,
-      resourceLimits: {
-        maxOldGenerationSizeMb,
-        maxYoungGenerationSizeMb
-      },
+      resourceLimits,
       stdout: true,
       stderr: true
     })
@@ -1646,36 +1627,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) {
@@ -1842,8 +1862,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/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.18.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.18.0",
+    "@platformatic/node": "3.18.0",
+    "@platformatic/gateway": "3.18.0",
+    "@platformatic/db": "3.18.0",
+    "@platformatic/sql-graphql": "3.18.0",
+    "@platformatic/sql-mapper": "3.18.0",
+    "@platformatic/wattpm-pprof-capture": "3.18.0",
+    "@platformatic/service": "3.18.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.18.0",
+    "@platformatic/generators": "3.18.0",
+    "@platformatic/foundation": "3.18.0",
+    "@platformatic/itc": "3.18.0",
+    "@platformatic/metrics": "3.18.0",
+    "@platformatic/telemetry": "3.18.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.18.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": [