@platformatic/runtime 2.69.0 → 2.70.0

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export type HttpsSchemasPlatformaticDevPlatformaticRuntime2690Json = {
+export type HttpsSchemasPlatformaticDevPlatformaticRuntime2700Json = {
   [k: string]: unknown;
 } & {
   $schema?: string;
@@ -29,7 +29,7 @@ export type HttpsSchemasPlatformaticDevPlatformaticRuntime2690Json = {
           maxELU?: number | string;
           maxHeapUsed?: number | string;
           maxHeapTotal?: number | string;
-          maxYoungGeneration?: number;
+          maxYoungGeneration?: number | string;
         };
         preload?: string | string[];
         arguments?: string[];
@@ -141,7 +141,7 @@ export type HttpsSchemasPlatformaticDevPlatformaticRuntime2690Json = {
     maxELU?: number | string;
     maxHeapUsed?: number | string;
     maxHeapTotal?: number | string;
-    maxYoungGeneration?: number;
+    maxYoungGeneration?: number | string;
   };
   undici?: {
     agentOptions?: {

package/lib/errors.js

@@ -13,6 +13,7 @@ module.exports = {
   WorkerExitedError: createError(`${ERROR_PREFIX}_SERVICE_EXIT`, 'The worker %s of the service "%s" exited prematurely with error code %d'),
   UnknownRuntimeAPICommandError: createError(`${ERROR_PREFIX}_UNKNOWN_RUNTIME_API_COMMAND`, 'Unknown Runtime API command "%s"'),
   ServiceNotFoundError: createError(`${ERROR_PREFIX}_SERVICE_NOT_FOUND`, 'Service %s not found. Available services are: %s'),
+  ServiceWorkerNotFoundError: createError(`${ERROR_PREFIX}_SERVICE_WORKER_NOT_FOUND`, 'Service %s worker %s not found'),
   ServiceNotStartedError: createError(`${ERROR_PREFIX}_SERVICE_NOT_STARTED`, "Service with id '%s' is not started"),
   ServiceStartTimeoutError: createError(`${ERROR_PREFIX}_SERVICE_START_TIMEOUT`, "Service with id '%s' failed to start in %dms."),
   FailedToRetrieveOpenAPISchemaError: createError(`${ERROR_PREFIX}_FAILED_TO_RETRIEVE_OPENAPI_SCHEMA`, 'Failed to retrieve OpenAPI schema for service with id "%s": %s'),

package/lib/runtime.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { ITC } = require('@platformatic/itc')
-const { features, ensureLoggableError, executeWithTimeout, deepmerge } = require('@platformatic/utils')
+const { features, ensureLoggableError, executeWithTimeout, deepmerge, parseMemorySize } = require('@platformatic/utils')
 const { once, EventEmitter } = require('node:events')
 const { createReadStream, watch, existsSync } = require('node:fs')
 const { readdir, readFile, stat, access } = require('node:fs/promises')
@@ -33,7 +33,8 @@ const {
   kHealthCheckTimer,
   kConfig,
   kWorkerStatus,
-  kStderrMarker
+  kStderrMarker,
+  kLastELU
 } = require('./worker/symbols')
 
 const fastify = require('fastify')
@@ -1148,10 +1149,13 @@ class Runtime extends EventEmitter {
       workerEnv['NODE_OPTIONS'] = `${originalNodeOptions} ${serviceConfig.nodeOptions}`.trim()
     }
 
+    const maxHeapTotal = typeof health.maxHeapTotal === 'string' ? parseMemorySize(health.maxHeapTotal) : health.maxHeapTotal
+    const maxYoungGeneration = typeof health.maxYoungGeneration === 'string' ? parseMemorySize(health.maxYoungGeneration) : health.maxYoungGeneration
+
     const maxOldGenerationSizeMb = Math.floor(
-      (health.maxYoungGeneration > 0 ? health.maxHeapTotal - health.maxYoungGeneration : health.maxHeapTotal) / (1024 * 1024)
+      (maxYoungGeneration > 0 ? maxHeapTotal - maxYoungGeneration : maxHeapTotal) / (1024 * 1024)
     )
-    const maxYoungGenerationSizeMb = health.maxYoungGeneration ? Math.floor(health.maxYoungGeneration / (1024 * 1024)) : undefined
+    const maxYoungGenerationSizeMb = maxYoungGeneration ? Math.floor(maxYoungGeneration / (1024 * 1024)) : undefined
 
     const worker = new Worker(kWorkerFile, {
       workerData: {
@@ -1323,18 +1327,39 @@ class Runtime extends EventEmitter {
     return worker
   }
 
-  #setupHealthCheck (config, serviceConfig, workersCount, id, index, workerId, worker, errorLabel) {
+  async #getHealth (worker) {
+    if (features.node.worker.getHeapStatistics) {
+      const { used_heap_size: heapUsed, total_heap_size: heapTotal } = await worker.getHeapStatistics()
+      const currentELU = worker.performance.eventLoopUtilization()
+      const elu = worker.performance.eventLoopUtilization(currentELU, worker[kLastELU]).utilization
+      worker[kLastELU] = currentELU
+      return { elu, heapUsed, heapTotal }
+    }
+
+    const health = await worker[kITC].send('getHealth')
+    return health
+  }
+
+  #setupHealthCheck (config, serviceConfig, workersCount, id, index, worker, errorLabel) {
     // Clear the timeout when exiting
     worker.on('exit', () => clearTimeout(worker[kHealthCheckTimer]))
 
     const { maxELU, maxHeapUsed, maxHeapTotal, maxUnhealthyChecks, interval } = worker[kConfig].health
+    const maxHeapTotalNumber = typeof maxHeapTotal === 'string' ? parseMemorySize(maxHeapTotal) : maxHeapTotal
+
     let unhealthyChecks = 0
 
     worker[kHealthCheckTimer] = setTimeout(async () => {
-      const health = await worker[kITC].send('getHealth')
-      const { elu, heapUsed } = health
-      const memoryUsage = heapUsed / maxHeapTotal
-      const unhealthy = elu > maxELU || memoryUsage > maxHeapUsed
+      let health, unhealthy, memoryUsage
+      try {
+        health = await this.#getHealth(worker)
+        memoryUsage = health.heapUsed / maxHeapTotalNumber
+        unhealthy = health.elu > maxELU || memoryUsage > maxHeapUsed
+      } catch (err) {
+        this.logger.error({ err }, `Failed to get health for ${errorLabel}.`)
+        unhealthy = true
+        memoryUsage = 0
+      }
 
       const serviceId = worker[kServiceId]
       this.emit('health', {
@@ -1347,9 +1372,9 @@ class Runtime extends EventEmitter {
       })
 
       if (unhealthy) {
-        if (elu > maxELU) {
+        if (health.elu > maxELU) {
           this.logger.error(
-            `The ${errorLabel} has an ELU of ${(elu * 100).toFixed(2)} %, above the maximum allowed usage of ${(maxELU * 100).toFixed(2)} %.`
+            `The ${errorLabel} has an ELU of ${(health.elu * 100).toFixed(2)} %, above the maximum allowed usage of ${(maxELU * 100).toFixed(2)} %.`
           )
         }
 
@@ -1367,14 +1392,14 @@ class Runtime extends EventEmitter {
       if (unhealthyChecks === maxUnhealthyChecks) {
         try {
           this.logger.error(
-            { elu, maxELU, memoryUsage, maxMemoryUsage: maxHeapUsed },
+            { elu: health.elu, maxELU, memoryUsage: health.heapUsed, maxMemoryUsage: maxHeapUsed },
             `The ${errorLabel} is unhealthy. Replacing it ...`
           )
 
-          await this.#replaceWorker(config, serviceConfig, workersCount, id, index, workerId, worker)
+          await this.#replaceWorker(config, serviceConfig, workersCount, id, index, worker)
         } catch (e) {
           this.logger.error(
-            { elu, maxELU, memoryUsage, maxMemoryUsage: maxHeapUsed },
+            { elu: health.elu, maxELU, memoryUsage: health.heapUsed, maxMemoryUsage: maxHeapUsed },
             `Cannot replace the ${errorLabel}. Forcefully terminating it ...`
           )
 
@@ -1397,7 +1422,6 @@ class Runtime extends EventEmitter {
     worker = undefined,
     disableRestartAttempts = false
   ) {
-    const workerId = `${id}:${index}`
     const label = this.#workerExtendedLabel(id, index, workersCount)
 
     if (!silent) {
@@ -1451,7 +1475,7 @@ class Runtime extends EventEmitter {
       if (enabled && config.restartOnError > 0) {
         worker[kHealthCheckTimer] = setTimeout(
           () => {
-            this.#setupHealthCheck(config, serviceConfig, workersCount, id, index, workerId, worker, label)
+            this.#setupHealthCheck(config, serviceConfig, workersCount, id, index, worker, label)
           },
           gracePeriod > 0 ? gracePeriod : 1
         )
@@ -1625,7 +1649,8 @@ class Runtime extends EventEmitter {
     await restartPromise
   }
 
-  async #replaceWorker (config, serviceConfig, workersCount, serviceId, index, workerId, worker) {
+  async #replaceWorker (config, serviceConfig, workersCount, serviceId, index, worker) {
+    const workerId = `${serviceId}:${index}`
     let newWorker
 
     try {
@@ -1685,7 +1710,7 @@ class Runtime extends EventEmitter {
         return null
       }
 
-      throw new errors.ServiceNotFoundError(serviceId, Array.from(this.#servicesIds).join(', '))
+      throw new errors.ServiceWorkerNotFoundError(serviceId, workerId)
     }
 
     if (ensureStarted) {
@@ -1849,10 +1874,16 @@ class Runtime extends EventEmitter {
 
   async getServiceResourcesInfo (id) {
     const workers = this.#workers.getCount(id)
-    return { workers }
+
+    const worker = await this.#getWorkerById(id, 0, false, false)
+    const health = worker[kConfig].health
+
+    return { workers, health }
   }
 
-  async #updateWorkerCount (serviceId, workers) {
+  async #updateServiceConfigWorkers (serviceId, workers) {
+    this.logger.info(`Updating service "${serviceId}" config workers to ${workers}`)
+
     this.#configManager.current.services.find(s => s.id === serviceId).workers = workers
     const service = await this.#getServiceById(serviceId)
     this.#workers.setCount(serviceId, workers)
@@ -1868,14 +1899,109 @@ class Runtime extends EventEmitter {
     const results = await Promise.allSettled(promises)
     for (const result of results) {
       if (result.status === 'rejected') {
+        this.logger.error({ err: result.reason }, `Cannot update service "${serviceId}" workers`)
         throw result.reason
       }
     }
   }
 
+  async #updateServiceConfigHealth (serviceId, health) {
+    this.logger.info(`Updating service "${serviceId}" config health heap to ${JSON.stringify(health)}`)
+    const { maxHeapTotal, maxYoungGeneration } = health
+
+    const service = this.#configManager.current.services.find(s => s.id === serviceId)
+    if (maxHeapTotal) {
+      service.health.maxHeapTotal = maxHeapTotal
+    }
+    if (maxYoungGeneration) {
+      service.health.maxYoungGeneration = maxYoungGeneration
+    }
+  }
+
+  /**
+   * Updates the resources of the services, such as the number of workers and health configurations (e.g., heap memory settings).
+   *
+   * This function handles three update scenarios for each service:
+   *  1. **Updating workers only**: Adjusts the number of workers for the service.
+   *  2. **Updating health configurations only**: Updates health parameters like `maxHeapTotal` or `maxYoungGeneration`.
+   *  3. **Updating both workers and health configurations**: Scales the workers and also applies health settings.
+   *
+   * When updating both workers and health:
+   *  - **Scaling down workers**: Stops extra workers, then restarts the remaining workers with the previous settings.
+   *  - **Scaling up workers**: Starts new workers with the updated heap settings, then restarts the old workers with the updated settings.
+   *
+   * Scaling up new resources (workers and/or heap memory) may fails due to insufficient memory, in this case the operation may fail partially or entirely.
+   * Scaling down is expected to succeed without issues.
+   *
+   * @param {Array<Object>} updates - An array of objects that define the updates for each service.
+   * @param {string} updates[].service - The ID of the service to update.
+   * @param {number} [updates[].workers] - The desired number of workers for the service. If omitted, workers will not be updated.
+   * @param {Object} [updates[].health] - The health configuration to update for the service, which may include:
+   *   @param {string|number} [updates[].health.maxHeapTotal] - The maximum heap memory for the service. Can be a valid memory string (e.g., '1G', '512MB') or a number representing bytes.
+   *   @param {string|number} [updates[].health.maxYoungGeneration] - The maximum young generation memory for the service. Can be a valid memory string (e.g., '128MB') or a number representing bytes.
+   *
+   * @returns {Promise<Array<Object>>} - A promise that resolves to an array of reports for each service, detailing the success or failure of the operations:
+   *   - `service`: The service ID.
+   *   - `workers`: The workers' update report, including the current, new number of workers, started workers, and success status.
+   *   - `health`: The health update report, showing the current and new heap settings, updated workers, and success status.
+   *
+   * @example
+   * await runtime.updateServicesResources([
+   *   { service: 'service-1', workers: 2, health: { maxHeapTotal: '1G', maxYoungGeneration: '128 MB' } },
+   *   { service: 'service-2', health: { maxHeapTotal: '1G' } },
+   *   { service: 'service-3', workers: 2 },
+   * ])
+   *
+   * In this example:
+   * - `service-1` will have 2 workers and updated heap memory configurations.
+   * - `service-2` will have updated heap memory settings (without changing workers).
+   * - `service-3` will have its workers set to 2 but no change in memory settings.
+   *
+   * @throws {InvalidArgumentError} - Throws if any update parameter is invalid, such as:
+   *   - Missing service ID.
+   *   - Invalid worker count (not a positive integer).
+   *   - Invalid memory size format for `maxHeapTotal` or `maxYoungGeneration`.
+   * @throws {ServiceNotFoundError} - Throws if the specified service ID does not exist in the current service configuration.
+   */
   async updateServicesResources (updates) {
-    if (this.#status === 'stopping' || this.#status === 'closed') return
+    if (this.#status === 'stopping' || this.#status === 'closed') {
+      this.logger.warn('Cannot update service resources when the runtime is stopping or closed')
+      return
+    }
+
+    const ups = await this.#validateUpdateServiceResources(updates)
+    const config = this.#configManager.current
 
+    const report = []
+    for (const update of ups) {
+      const { serviceId, config: serviceConfig, workers, health, currentWorkers, currentHealth } = update
+
+      if (workers && health) {
+        const r = await this.#updateServiceWorkersAndHealth(serviceId, config, serviceConfig, workers, health, currentWorkers, currentHealth)
+        report.push({
+          service: serviceId,
+          workers: r.workers,
+          health: r.health
+        })
+      } else if (health) {
+        const r = await this.#updateServiceHealth(serviceId, config, serviceConfig, currentWorkers, currentHealth, health)
+        report.push({
+          service: serviceId,
+          health: r.health
+        })
+      } else if (workers) {
+        const r = await this.#updateServiceWorkers(serviceId, config, serviceConfig, workers, currentWorkers)
+        report.push({
+          service: serviceId,
+          workers: r.workers
+        })
+      }
+    }
+
+    return report
+  }
+
+  async #validateUpdateServiceResources (updates) {
     if (!Array.isArray(updates)) {
       throw new errors.InvalidArgumentError('updates', 'must be an array')
     }
@@ -1884,47 +2010,207 @@ class Runtime extends EventEmitter {
     }
 
     const config = this.#configManager.current
-
+    const validatedUpdates = []
     for (const update of updates) {
-      const { service: serviceId, workers } = update
+      const { service: serviceId } = update
 
-      if (typeof workers !== 'number') {
-        throw new errors.InvalidArgumentError('workers', 'must be a number')
-      }
       if (!serviceId) {
         throw new errors.InvalidArgumentError('service', 'must be a string')
       }
-      if (workers <= 0) {
-        throw new errors.InvalidArgumentError('workers', 'must be greater than 0')
-      }
-      if (workers > MAX_WORKERS) {
-        throw new errors.InvalidArgumentError('workers', `must be less than ${MAX_WORKERS}`)
-      }
       const serviceConfig = config.services.find(s => s.id === serviceId)
       if (!serviceConfig) {
         throw new errors.ServiceNotFoundError(serviceId, Array.from(this.#servicesIds).join(', '))
       }
 
-      const { workers: currentWorkers } = await this.getServiceResourcesInfo(serviceId)
-      if (currentWorkers === workers) {
-        this.logger.warn({ serviceId, workers }, 'No change in the number of workers for service')
-        continue
+      const { workers: currentWorkers, health: currentHealth } = await this.getServiceResourcesInfo(serviceId)
+
+      let workers
+      if (update.workers !== undefined) {
+        if (typeof update.workers !== 'number') {
+          throw new errors.InvalidArgumentError('workers', 'must be a number')
+        }
+        if (update.workers <= 0) {
+          throw new errors.InvalidArgumentError('workers', 'must be greater than 0')
+        }
+        if (update.workers > MAX_WORKERS) {
+          throw new errors.InvalidArgumentError('workers', `must be less than ${MAX_WORKERS}`)
+        }
+
+        if (currentWorkers === update.workers) {
+          this.logger.warn({ serviceId, workers: update.workers }, 'No change in the number of workers for service')
+        } else {
+          workers = update.workers
+        }
       }
 
-      if (currentWorkers < workers) {
-        await this.#updateWorkerCount(serviceId, workers)
+      let maxHeapTotal, maxYoungGeneration
+      if (update.health) {
+        if (update.health.maxHeapTotal !== undefined) {
+          if (typeof update.health.maxHeapTotal === 'string') {
+            try {
+              maxHeapTotal = parseMemorySize(update.health.maxHeapTotal)
+            } catch {
+              throw new errors.InvalidArgumentError('maxHeapTotal', 'must be a valid memory size')
+            }
+          } else if (typeof update.health.maxHeapTotal === 'number') {
+            maxHeapTotal = update.health.maxHeapTotal
+            if (update.health.maxHeapTotal <= 0) {
+              throw new errors.InvalidArgumentError('maxHeapTotal', 'must be greater than 0')
+            }
+          } else {
+            throw new errors.InvalidArgumentError('maxHeapTotal', 'must be a number or a string representing a memory size')
+          }
+
+          if (currentHealth.maxHeapTotal === maxHeapTotal) {
+            this.logger.warn({ serviceId, maxHeapTotal }, 'No change in the max heap total for service')
+            maxHeapTotal = undefined
+          }
+        }
+
+        if (update.health.maxYoungGeneration !== undefined) {
+          if (typeof update.health.maxYoungGeneration === 'string') {
+            try {
+              maxYoungGeneration = parseMemorySize(update.health.maxYoungGeneration)
+            } catch {
+              throw new errors.InvalidArgumentError('maxYoungGeneration', 'must be a valid memory size')
+            }
+          } else if (typeof update.health.maxYoungGeneration === 'number') {
+            maxYoungGeneration = update.health.maxYoungGeneration
+            if (update.health.maxYoungGeneration <= 0) {
+              throw new errors.InvalidArgumentError('maxYoungGeneration', 'must be greater than 0')
+            }
+          } else {
+            throw new errors.InvalidArgumentError('maxYoungGeneration', 'must be a number or a string representing a memory size')
+          }
+
+          if (currentHealth.maxYoungGeneration && currentHealth.maxYoungGeneration === maxYoungGeneration) {
+            this.logger.warn({ serviceId, maxYoungGeneration }, 'No change in the max young generation for service')
+            maxYoungGeneration = undefined
+          }
+        }
+      }
+
+      if (workers || maxHeapTotal || maxYoungGeneration) {
+        let health
+        if (maxHeapTotal || maxYoungGeneration) {
+          health = { }
+          if (maxHeapTotal) {
+            health.maxHeapTotal = maxHeapTotal
+          }
+          if (maxYoungGeneration) {
+            health.maxYoungGeneration = maxYoungGeneration
+          }
+        }
+        validatedUpdates.push({ serviceId, config: serviceConfig, workers, health, currentWorkers, currentHealth })
+      }
+    }
+
+    return validatedUpdates
+  }
+
+  async #updateServiceWorkersAndHealth (serviceId, config, serviceConfig, workers, health, currentWorkers, currentHealth) {
+    if (currentWorkers > workers) {
+      // stop workers
+      const reportWorkers = await this.#updateServiceWorkers(serviceId, config, serviceConfig, workers, currentWorkers)
+      // update heap for current workers
+      const reportHealth = await this.#updateServiceHealth(serviceId, config, serviceConfig, workers, currentHealth, health)
+
+      return { workers: reportWorkers, health: reportHealth }
+    } else {
+      // update service heap
+      await this.#updateServiceConfigHealth(serviceId, health)
+      // start new workers with new heap
+      const reportWorkers = await this.#updateServiceWorkers(serviceId, config, serviceConfig, workers, currentWorkers)
+      // update heap for current workers
+      const reportHealth = await this.#updateServiceHealth(serviceId, config, serviceConfig, currentWorkers, currentHealth, health, false)
+
+      return { workers: reportWorkers, health: reportHealth }
+    }
+  }
+
+  async #updateServiceHealth (serviceId, config, serviceConfig, currentWorkers, currentHealth, health, updateConfig = true) {
+    const report = {
+      current: currentHealth,
+      new: health,
+      updated: []
+    }
+    try {
+      if (updateConfig) {
+        await this.#updateServiceConfigHealth(serviceId, health)
+      }
+
+      for (let i = 0; i < currentWorkers; i++) {
+        this.logger.info({ health: { current: currentHealth, new: health } }, `Restarting service "${serviceId}" worker ${i} to update config health heap...`)
+
+        const worker = await this.#getWorkerById(serviceId, i)
+        if (health.maxHeapTotal) { worker[kConfig].health.maxHeapTotal = health.maxHeapTotal }
+        if (health.maxYoungGeneration) { worker[kConfig].health.maxYoungGeneration = health.maxYoungGeneration }
+
+        await this.#replaceWorker(config, serviceConfig, currentWorkers, serviceId, i, worker)
+        report.updated.push(i)
+        this.logger.info({ health: { current: currentHealth, new: health } }, `Restarted service "${serviceId}" worker ${i}`)
+      }
+      report.success = true
+    } catch (err) {
+      if (report.updated.length < 1) {
+        this.logger.error({ err }, 'Cannot update service health heap, no worker updated')
+        await this.#updateServiceConfigHealth(serviceId, currentHealth)
+      } else {
+        this.logger.error({ err }, `Cannot update service health heap, updated workers: ${report.updated.length} out of ${currentWorkers}`)
+      }
+      report.success = false
+    }
+    return report
+  }
+
+  async #updateServiceWorkers (serviceId, config, serviceConfig, workers, currentWorkers) {
+    const report = {
+      current: currentWorkers,
+      new: workers
+    }
+    if (currentWorkers < workers) {
+      report.started = []
+      try {
+        await this.#updateServiceConfigWorkers(serviceId, workers)
         for (let i = currentWorkers; i < workers; i++) {
           await this.#setupWorker(config, serviceConfig, workers, serviceId, i)
           await this.#startWorker(config, serviceConfig, workers, serviceId, i, false, 0)
+          report.started.push(i)
         }
-      } else {
+        report.success = true
+      } catch (err) {
+        if (report.started.length < 1) {
+          this.logger.error({ err }, 'Cannot start service workers, no worker started')
+          await this.#updateServiceConfigWorkers(serviceId, currentWorkers)
+        } else {
+          this.logger.error({ err }, `Cannot start service workers, started workers: ${report.started.length} out of ${workers}`)
+          await this.#updateServiceConfigWorkers(serviceId, currentWorkers + report.started.length)
+        }
+        report.success = false
+      }
+    } else {
+      // keep the current workers count until all the service workers are all stopped
+      report.stopped = []
+      try {
         for (let i = currentWorkers - 1; i >= workers; i--) {
-          // keep the current workers count until the workers are stopped
-          await this.#stopWorker(currentWorkers, serviceId, i, false)
+          const worker = await this.#getWorkerById(serviceId, i, false, false)
+          await sendViaITC(worker, 'removeFromMesh')
+          await this.#stopWorker(currentWorkers, serviceId, i, false, worker)
+          report.stopped.push(i)
+        }
+        await this.#updateServiceConfigWorkers(serviceId, workers)
+        report.success = true
+      } catch (err) {
+        if (report.stopped.length < 1) {
+          this.logger.error({ err }, 'Cannot stop service workers, no worker stopped')
+        } else {
+          this.logger.error({ err }, `Cannot stop service workers, stopped workers: ${report.stopped.length} out of ${workers}`)
+          await this.#updateServiceConfigWorkers(serviceId, currentWorkers - report.stopped)
         }
-        await this.#updateWorkerCount(serviceId, workers)
+        report.success = false
       }
     }
+    return report
   }
 }
 

package/lib/worker/interceptors.js

@@ -164,14 +164,16 @@ async function getDispatcherOpts (undiciConfig) {
 
 function createThreadInterceptor (runtimeConfig) {
   const telemetry = runtimeConfig.telemetry
-  const hooks = telemetry ? createTelemetryThreadInterceptorHooks() : {}
+
+  const telemetryHooks = telemetry ? createTelemetryThreadInterceptorHooks() : {}
+
   const threadDispatcher = wire({
     // Specifying the domain is critical to avoid flooding the DNS
     // with requests for a domain that's never going to exist.
     domain: '.plt.local',
     port: parentPort,
     timeout: runtimeConfig.serviceTimeout,
-    ...hooks
+    ...telemetryHooks,
   })
   return threadDispatcher
 }

package/lib/worker/symbols.js

@@ -9,6 +9,7 @@ const kITC = Symbol.for('plt.runtime.itc')
 const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer')
 const kWorkerStatus = Symbol('plt.runtime.worker.status')
 const kInterceptors = Symbol.for('plt.runtime.worker.interceptors')
+const kLastELU = Symbol.for('plt.runtime.worker.lastELU')
 
 // This string marker should be safe to use since it belongs to Unicode private area
 const kStderrMarker = '\ue002'
@@ -21,6 +22,7 @@ module.exports = {
   kWorkerId,
   kITC,
   kHealthCheckTimer,
+  kLastELU,
   kWorkerStatus,
   kStderrMarker,
   kInterceptors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "2.69.0",
+  "version": "2.70.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -37,12 +37,12 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "2.69.0",
-    "@platformatic/db": "2.69.0",
-    "@platformatic/node": "2.69.0",
-    "@platformatic/service": "2.69.0",
-    "@platformatic/sql-graphql": "2.69.0",
-    "@platformatic/sql-mapper": "2.69.0"
+    "@platformatic/composer": "2.70.0",
+    "@platformatic/db": "2.70.0",
+    "@platformatic/node": "2.70.0",
+    "@platformatic/service": "2.70.0",
+    "@platformatic/sql-graphql": "2.70.0",
+    "@platformatic/sql-mapper": "2.70.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -50,7 +50,6 @@
     "@fastify/websocket": "^11.0.0",
     "@hapi/topo": "^6.0.2",
     "@opentelemetry/api": "^1.8.0",
-    "@platformatic/http-metrics": "^0.2.1",
     "@platformatic/undici-cache-memory": "^0.8.1",
     "@watchable/unpromise": "^1.0.2",
     "change-case-all": "^2.1.0",
@@ -75,23 +74,24 @@
     "sonic-boom": "^4.2.0",
     "tail-file-stream": "^0.2.0",
     "undici": "^7.0.0",
-    "undici-thread-interceptor": "^0.13.1",
+    "undici-thread-interceptor": "^0.14.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "2.69.0",
-    "@platformatic/config": "2.69.0",
-    "@platformatic/generators": "2.69.0",
-    "@platformatic/itc": "2.69.0",
-    "@platformatic/telemetry": "2.69.0",
-    "@platformatic/ts-compiler": "2.69.0",
-    "@platformatic/utils": "2.69.0"
+    "@platformatic/basic": "2.70.0",
+    "@platformatic/generators": "2.70.0",
+    "@platformatic/metrics": "2.70.0",
+    "@platformatic/itc": "2.70.0",
+    "@platformatic/telemetry": "2.70.0",
+    "@platformatic/ts-compiler": "2.70.0",
+    "@platformatic/utils": "2.70.0",
+    "@platformatic/config": "2.70.0"
   },
   "scripts": {
-    "test": "pnpm run lint && borp --concurrency=1 --timeout=600000 && tsd",
+    "test": "pnpm run lint && borp --concurrency=1 --timeout=1200000 && tsd",
     "test:main": "borp --concurrency=1 --timeout=300000 test/*.test.js test/*.test.mjs test/versions/*.test.js test/versions/*.test.mjs",
     "test:api": "borp --concurrency=1 --timeout=300000 test/api/*.test.js test/api/*.test.mjs test/management-api/*.test.js test/management-api/*.test.mjs",
     "test:cli": "borp --concurrency=1 --timeout=300000 test/cli/*.test.js test/cli/*.test.mjs test/cli/**/*.test.js test/cli/**/*.test.mjs",
     "test:start": "borp --concurrency=1 --timeout=300000 test/start/*.test.js test/start/*.test.mjs",
-    "test:multiple-workers": "borp --concurrency=1 --timeout=600000 test/multiple-workers/*.test.js test/multiple-workers/*.test.mjs",
+    "test:multiple-workers": "borp --concurrency=1 --timeout=1200000 test/multiple-workers/*.test.js test/multiple-workers/*.test.mjs",
     "test:types": "tsd",
     "coverage": "pnpm run lint && borp -X fixtures -X test -C --concurrency=1 --timeout=300000 && tsd",
     "gen-schema": "node lib/schema.js > schema.json",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.69.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.70.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
   "properties": {
@@ -76,6 +76,7 @@
               },
               "health": {
                 "type": "object",
+                "default": {},
                 "properties": {
                   "enabled": {
                     "anyOf": [
@@ -156,8 +157,15 @@
                     ]
                   },
                   "maxYoungGeneration": {
-                    "type": "number",
-                    "minimum": 0
+                    "anyOf": [
+                      {
+                        "type": "number",
+                        "minimum": 0
+                      },
+                      {
+                        "type": "string"
+                      }
+                    ]
                   }
                 },
                 "additionalProperties": false
@@ -244,6 +252,7 @@
           },
           "health": {
             "type": "object",
+            "default": {},
             "properties": {
               "enabled": {
                 "anyOf": [
@@ -324,8 +333,15 @@
                 ]
               },
               "maxYoungGeneration": {
-                "type": "number",
-                "minimum": 0
+                "anyOf": [
+                  {
+                    "type": "number",
+                    "minimum": 0
+                  },
+                  {
+                    "type": "string"
+                  }
+                ]
               }
             },
             "additionalProperties": false
@@ -477,6 +493,7 @@
           },
           "health": {
             "type": "object",
+            "default": {},
             "properties": {
               "enabled": {
                 "anyOf": [
@@ -557,8 +574,15 @@
                 ]
               },
               "maxYoungGeneration": {
-                "type": "number",
-                "minimum": 0
+                "anyOf": [
+                  {
+                    "type": "number",
+                    "minimum": 0
+                  },
+                  {
+                    "type": "string"
+                  }
+                ]
               }
             },
             "additionalProperties": false
@@ -976,7 +1000,6 @@
       "default": {},
       "properties": {
         "enabled": {
-          "default": true,
           "anyOf": [
             {
               "type": "boolean"
@@ -984,10 +1007,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": true
         },
         "interval": {
-          "default": 30000,
           "anyOf": [
             {
               "type": "number",
@@ -996,10 +1019,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 30000
         },
         "gracePeriod": {
-          "default": 30000,
           "anyOf": [
             {
               "type": "number",
@@ -1008,10 +1031,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 30000
         },
         "maxUnhealthyChecks": {
-          "default": 10,
           "anyOf": [
             {
               "type": "number",
@@ -1020,10 +1043,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 10
         },
         "maxELU": {
-          "default": 0.99,
           "anyOf": [
             {
               "type": "number",
@@ -1033,10 +1056,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 0.99
         },
         "maxHeapUsed": {
-          "default": 0.99,
           "anyOf": [
             {
               "type": "number",
@@ -1046,10 +1069,10 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 0.99
         },
         "maxHeapTotal": {
-          "default": 4294967296,
           "anyOf": [
             {
               "type": "number",
@@ -1058,11 +1081,19 @@
             {
               "type": "string"
             }
-          ]
+          ],
+          "default": 4294967296
         },
         "maxYoungGeneration": {
-          "type": "number",
-          "minimum": 0
+          "anyOf": [
+            {
+              "type": "number",
+              "minimum": 0
+            },
+            {
+              "type": "string"
+            }
+          ]
         }
       },
       "additionalProperties": false