@platformatic/runtime 3.12.0 → 3.13.1

package/index.d.ts

@@ -55,7 +55,8 @@ export module symbols {
   export declare const kWorkerId: unique symbol
   export declare const kITC: unique symbol
   export declare const kHealthCheckTimer: unique symbol
-  export declare const kLastELU: unique symbol
+  export declare const kLastHealthCheckELU: unique symbol
+  export declare const kLastVerticalScalerELU: unique symbol
   export declare const kWorkerStatus: unique symbol
   export declare const kStderrMarker: string
   export declare const kInterceptors: unique symbol

package/lib/errors.js

@@ -127,3 +127,7 @@ export const MissingPprofCapture = createError(
   `${ERROR_PREFIX}_MISSING_PPROF_CAPTURE`,
   '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'
+)

package/lib/prom-server.js

@@ -21,19 +21,17 @@ const DEFAULT_LIVENESS_FAIL_BODY = 'ERR'
 
 async function checkReadiness (runtime) {
   const workers = await runtime.getWorkers()
+  const applications = await runtime.getApplicationsIds()
 
   // Make sure there is at least one started worker
-  const applications = new Set()
   const started = new Set()
   for (const worker of Object.values(workers)) {
-    applications.add(worker.application)
-
     if (worker.status === 'started') {
       started.add(worker.application)
     }
   }
 
-  if (started.size !== applications.size) {
+  if (started.size !== applications.length) {
     return { status: false }
   }
 

package/lib/runtime.js

@@ -36,7 +36,8 @@ import {
   MissingPprofCapture,
   RuntimeAbortedError,
   RuntimeExitedError,
-  WorkerNotFoundError
+  WorkerNotFoundError,
+  GetHeapStatisticUnavailable
 } from './errors.js'
 import { abstractLogger, createLogger } from './logger.js'
 import { startManagementApi } from './management-api.js'
@@ -56,7 +57,8 @@ import {
   kHealthCheckTimer,
   kId,
   kITC,
-  kLastELU,
+  kLastHealthCheckELU,
+  kLastVerticalScalerELU,
   kStderrMarker,
   kWorkerId,
   kWorkersBroadcast,
@@ -107,6 +109,7 @@ export class Runtime extends EventEmitter {
 
   #applicationsConfigsPatches
   #workers
+  #workersConfigs
   #workersBroadcastChannel
   #workerITCHandlers
   #restartingWorkers
@@ -190,27 +193,24 @@ export class Runtime extends EventEmitter {
 
     this.#createWorkersBroadcastChannel()
 
-    const workersConfig = []
-    for (const application of config.applications) {
-      const count = application.workers ?? this.#config.workers ?? 1
+    this.#workersConfigs = {}
+    for (const application of this.#config.applications) {
+      let count = application.workers ?? this.#config.workers ?? 1
       if (count > 1 && application.entrypoint && !features.node.reusePort) {
         this.logger.warn(
           `"${application.id}" is set as the entrypoint, but reusePort is not available in your OS; setting workers to 1 instead of ${count}`
         )
-        workersConfig.push({ id: application.id, workers: 1 })
-      } else {
-        workersConfig.push({ id: application.id, workers: count })
+        count = 1
       }
+      this.#workersConfigs[application.id] = { count }
     }
 
-    this.#workers.configure(workersConfig)
-
     if (this.#isProduction) {
-      this.#env['PLT_DEV'] = 'false'
-      this.#env['PLT_ENVIRONMENT'] = 'production'
+      this.#env.PLT_DEV = 'false'
+      this.#env.PLT_ENVIRONMENT = 'production'
     } else {
-      this.#env['PLT_DEV'] = 'true'
-      this.#env['PLT_ENVIRONMENT'] = 'development'
+      this.#env.PLT_DEV = 'true'
+      this.#env.PLT_ENVIRONMENT = 'development'
     }
 
     await this.#setupApplications()
@@ -479,13 +479,6 @@ export class Runtime extends EventEmitter {
   }
 
   async startApplication (id, silent = false) {
-    // Since when an application is stopped the worker is deleted, we consider an application start if its first application
-    // is no longer in the init phase
-    const firstWorker = this.#workers.get(`${id}:0`)
-    if (firstWorker && firstWorker[kWorkerStatus] !== 'boot' && firstWorker[kWorkerStatus] !== 'init') {
-      throw new ApplicationAlreadyStartedError()
-    }
-
     const config = this.#config
     const applicationConfig = config.applications.find(s => s.id === id)
 
@@ -493,12 +486,21 @@ export class Runtime extends EventEmitter {
       throw new ApplicationNotFoundError(id, this.getApplicationsIds().join(', '))
     }
 
-    const workersCount = await this.#workers.getCount(applicationConfig.id)
+    const workersConfigs = this.#workersConfigs[id]
+
+    for (let i = 0; i < workersConfigs.count; i++) {
+      const worker = this.#workers.get(`${id}:${i}`)
+      const status = worker?.[kWorkerStatus]
+
+      if (status && status !== 'boot' && status !== 'init') {
+        throw new ApplicationAlreadyStartedError()
+      }
+    }
 
     this.emitAndNotify('application:starting', id)
 
-    for (let i = 0; i < workersCount; i++) {
-      await this.#startWorker(config, applicationConfig, workersCount, id, i, silent)
+    for (let i = 0; i < workersConfigs.count; i++) {
+      await this.#startWorker(config, applicationConfig, workersConfigs.count, id, i, silent)
     }
 
     this.emitAndNotify('application:started', id)
@@ -512,13 +514,15 @@ export class Runtime extends EventEmitter {
       throw new ApplicationNotFoundError(id, this.getApplicationsIds().join(', '))
     }
 
-    const workersCount = await this.#workers.getCount(applicationConfig.id)
+    const workersIds = this.#workers.getKeys(id)
+    const workersCount = workersIds.length
 
     this.emitAndNotify('application:stopping', id)
 
     if (typeof workersCount === 'number') {
       const stopInvocations = []
-      for (let i = 0; i < workersCount; i++) {
+      for (const workerId of workersIds) {
+        const i = parseInt(workerId.split(':')[1])
         stopInvocations.push([workersCount, id, i, silent, undefined, dependents])
       }
 
@@ -531,13 +535,15 @@ export class Runtime extends EventEmitter {
   async restartApplication (id) {
     const config = this.#config
     const applicationConfig = this.#config.applications.find(s => s.id === id)
-    const workersCount = await this.#workers.getCount(id)
+
+    const workersIds = await this.#workers.getKeys(id)
+    const workersCount = workersIds.length
 
     this.emitAndNotify('application:restarting', id)
 
     for (let i = 0; i < workersCount; i++) {
-      const label = `${id}:${i}`
-      const worker = this.#workers.get(label)
+      const workerId = workersIds[i]
+      const worker = this.#workers.get(workerId)
 
       if (i > 0 && config.workersRestartDelay > 0) {
         await sleep(config.workersRestartDelay)
@@ -861,14 +867,11 @@ export class Runtime extends EventEmitter {
   async getCustomHealthChecks () {
     const status = {}
 
-    for (const [application, { count }] of Object.entries(this.#workers.configuration)) {
-      for (let i = 0; i < count; i++) {
-        const label = `${application}:${i}`
-        const worker = this.#workers.get(label)
-
-        if (worker) {
-          status[label] = await sendViaITC(worker, 'getCustomHealthCheck')
-        }
+    for (const application of this.#config.applications) {
+      const workersIds = this.#workers.getKeys(application.id)
+      for (const workerId of workersIds) {
+        const worker = this.#workers.get(workerId)
+        status[workerId] = await sendViaITC(worker, 'getCustomHealthCheck')
       }
     }
 
@@ -878,14 +881,11 @@ export class Runtime extends EventEmitter {
   async getCustomReadinessChecks () {
     const status = {}
 
-    for (const [application, { count }] of Object.entries(this.#workers.configuration)) {
-      for (let i = 0; i < count; i++) {
-        const label = `${application}:${i}`
-        const worker = this.#workers.get(label)
-
-        if (worker) {
-          status[label] = await sendViaITC(worker, 'getCustomReadinessCheck')
-        }
+    for (const application of this.#config.applications) {
+      const workersIds = this.#workers.getKeys(application.id)
+      for (const workerId of workersIds) {
+        const worker = this.#workers.get(workerId)
+        status[workerId] = await sendViaITC(worker, 'getCustomReadinessCheck')
       }
     }
 
@@ -1055,12 +1055,11 @@ export class Runtime extends EventEmitter {
   }
 
   async getApplicationResourcesInfo (id) {
-    const workers = this.#workers.getCount(id)
-
-    const worker = await this.#getWorkerById(id, 0, false, false)
+    const workersCount = this.#workers.getKeys(id).length
+    const worker = await this.#getWorkerByIdOrNext(id, 0, false, false)
     const health = worker[kConfig].health
 
-    return { workers, health }
+    return { workers: workersCount, health }
   }
 
   getApplicationsIds () {
@@ -1080,17 +1079,13 @@ export class Runtime extends EventEmitter {
   async getWorkers () {
     const status = {}
 
-    for (const [application, { count }] of Object.entries(this.#workers.configuration)) {
-      for (let i = 0; i < count; i++) {
-        const label = `${application}:${i}`
-        const worker = this.#workers.get(label)
-
-        status[label] = {
-          application,
-          worker: i,
-          status: worker?.[kWorkerStatus] ?? 'exited',
-          thread: worker?.threadId
-        }
+    for (const [key, worker] of this.#workers.entries()) {
+      const [application, index] = key.split(':')
+      status[key] = {
+        application,
+        worker: index,
+        status: worker[kWorkerStatus],
+        thread: worker.threadId
       }
     }
 
@@ -1141,7 +1136,7 @@ export class Runtime extends EventEmitter {
     }
 
     if (this.#isProduction) {
-      applicationDetails.workers = this.#workers.getCount(id)
+      applicationDetails.workers = this.#workers.getKeys(id).length
     }
 
     if (entrypoint) {
@@ -1273,12 +1268,13 @@ export class Runtime extends EventEmitter {
     }
 
     const config = this.#config
-    const workersCount = await this.#workers.getCount(applicationConfig.id)
+
+    const workersConfigs = this.#workersConfigs[applicationConfig.id]
     const id = applicationConfig.id
     const setupInvocations = []
 
-    for (let i = 0; i < workersCount; i++) {
-      setupInvocations.push([config, applicationConfig, workersCount, id, i])
+    for (let i = 0; i < workersConfigs.count; i++) {
+      setupInvocations.push([config, applicationConfig, workersConfigs.count, id, i])
     }
 
     await executeInParallel(this.#setupWorker.bind(this), setupInvocations, this.#concurrency)
@@ -1344,9 +1340,9 @@ export class Runtime extends EventEmitter {
     const workerEnv = structuredClone(this.#env)
 
     if (applicationConfig.nodeOptions?.trim().length > 0) {
-      const originalNodeOptions = workerEnv['NODE_OPTIONS'] ?? ''
+      const originalNodeOptions = workerEnv.NODE_OPTIONS ?? ''
 
-      workerEnv['NODE_OPTIONS'] = `${originalNodeOptions} ${applicationConfig.nodeOptions}`.trim()
+      workerEnv.NODE_OPTIONS = `${originalNodeOptions} ${applicationConfig.nodeOptions}`.trim()
     }
 
     const maxHeapTotal =
@@ -1391,7 +1387,7 @@ export class Runtime extends EventEmitter {
       stderr: true
     })
 
-    this.#handleWorkerStandardStreams(worker, applicationId, workersCount > 1 ? index : undefined)
+    this.#handleWorkerStandardStreams(worker, applicationId, index)
 
     // Make sure the listener can handle a lot of API requests at once before raising a warning
     worker.setMaxListeners(1e3)
@@ -1445,10 +1441,10 @@ export class Runtime extends EventEmitter {
       })
     })
 
-    worker[kId] = workersCount > 1 ? workerId : applicationId
+    worker[kId] = workerId
     worker[kFullId] = workerId
     worker[kApplicationId] = applicationId
-    worker[kWorkerId] = workersCount > 1 ? index : undefined
+    worker[kWorkerId] = index
     worker[kWorkerStatus] = 'boot'
 
     if (inspectorOptions) {
@@ -1527,17 +1523,21 @@ export class Runtime extends EventEmitter {
     return worker
   }
 
-  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[kLastELU] ? worker.performance.eventLoopUtilization(currentELU, worker[kLastELU]) : currentELU
-      worker[kLastELU] = currentELU
-      return { elu: elu.utilization, heapUsed, heapTotal }
+  async #getHealth (worker, options = {}) {
+    if (!features.node.worker.getHeapStatistics) {
+      throw new GetHeapStatisticUnavailable()
+    }
+
+    const currentELU = worker.performance.eventLoopUtilization()
+    const previousELU = options.previousELU
+
+    let elu = currentELU
+    if (previousELU) {
+      elu = worker.performance.eventLoopUtilization(elu, previousELU)
     }
 
-    const health = await worker[kITC].send('getHealth')
-    return health
+    const { used_heap_size: heapUsed, total_heap_size: heapTotal } = await worker.getHeapStatistics()
+    return { elu: elu.utilization, heapUsed, heapTotal, currentELU }
   }
 
   #setupHealthCheck (config, applicationConfig, workersCount, id, index, worker, errorLabel) {
@@ -1556,11 +1556,15 @@ export class Runtime extends EventEmitter {
 
       let health, unhealthy, memoryUsage
       try {
-        health = await this.#getHealth(worker)
+        health = await this.#getHealth(worker, {
+          previousELU: worker[kLastHealthCheckELU]
+        })
+        worker[kLastHealthCheckELU] = health.currentELU
         memoryUsage = health.heapUsed / maxHeapTotalNumber
         unhealthy = health.elu > maxELU || memoryUsage > maxHeapUsed
       } catch (err) {
         this.logger.error({ err }, `Failed to get health for ${errorLabel}.`)
+        worker[kLastHealthCheckELU] = null
         unhealthy = true
         memoryUsage = -1
         health = { elu: -1, heapUsed: -1, heapTotal: -1 }
@@ -1635,7 +1639,7 @@ export class Runtime extends EventEmitter {
     }
 
     if (!worker) {
-      worker = await this.#getWorkerById(id, index, false, false)
+      worker = await this.#getWorkerByIdOrNext(id, index, false, false)
     }
 
     const eventPayload = { application: id, worker: index, workersCount }
@@ -1643,7 +1647,7 @@ export class Runtime extends EventEmitter {
     // The application was stopped, recreate the thread
     if (!worker) {
       await this.#setupApplication(applicationConfig, index)
-      worker = await this.#getWorkerById(id, index)
+      worker = await this.#getWorkerByIdOrNext(id, index)
     }
 
     worker[kWorkerStatus] = 'starting'
@@ -1746,7 +1750,7 @@ export class Runtime extends EventEmitter {
 
   async #stopWorker (workersCount, id, index, silent, worker, dependents) {
     if (!worker) {
-      worker = await this.#getWorkerById(id, index, false, false)
+      worker = await this.#getWorkerByIdOrNext(id, index, false, false)
     }
 
     if (!worker) {
@@ -1827,10 +1831,8 @@ export class Runtime extends EventEmitter {
     return this.#cleanupWorker(worker)
   }
 
-  #workerExtendedLabel (applicationId, workerId, workersCount) {
-    return workersCount > 1
-      ? `worker ${workerId} of the application "${applicationId}"`
-      : `application "${applicationId}"`
+  #workerExtendedLabel (applicationId, workerId, _workersCount) {
+    return `worker ${workerId} of the application "${applicationId}"`
   }
 
   async #restartCrashedWorker (config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt) {
@@ -1924,7 +1926,6 @@ export class Runtime extends EventEmitter {
   }
 
   async #getApplicationById (applicationId, ensureStarted = false, mustExist = true) {
-    // If the applicationId includes the worker, properly split
     let workerId
     const matched = applicationId.match(/^(.+):(\d+)$/)
 
@@ -1933,16 +1934,19 @@ export class Runtime extends EventEmitter {
       workerId = matched[2]
     }
 
-    return this.#getWorkerById(applicationId, workerId, ensureStarted, mustExist)
+    return this.#getWorkerByIdOrNext(applicationId, workerId, ensureStarted, mustExist)
   }
 
-  async #getWorkerById (applicationId, workerId, ensureStarted = false, mustExist = true) {
+  // This method can work in two modes: when workerId is provided, it will return the specific worker
+  // otherwise it will return the next available worker for the application.
+  async #getWorkerByIdOrNext (applicationId, workerId, ensureStarted = false, mustExist = true) {
     let worker
 
-    if (typeof workerId !== 'undefined') {
-      worker = this.#workers.get(`${applicationId}:${workerId}`)
-    } else {
+    // Note that in this class "== null" is purposely used instead of "===" to check for both null and undefined
+    if (workerId == null) {
       worker = this.#workers.next(applicationId)
+    } else {
+      worker = this.#workers.get(`${applicationId}:${workerId}`)
     }
 
     const applicationsIds = this.getApplicationsIds()
@@ -1953,8 +1957,8 @@ export class Runtime extends EventEmitter {
       }
 
       if (applicationsIds.includes(applicationId)) {
-        const availableWorkers = Array.from(this.#workers.keys())
-          .filter(key => key.startsWith(applicationId + ':'))
+        const availableWorkers = this.#workers
+          .getKeys(applicationId)
           .map(key => key.split(':')[1])
           .join(', ')
         throw new WorkerNotFoundError(workerId, applicationId, availableWorkers)
@@ -2019,7 +2023,7 @@ export class Runtime extends EventEmitter {
       )
     }
 
-    const target = await this.#getWorkerById(application, worker, true, true)
+    const target = await this.#getWorkerByIdOrNext(application, worker, true, true)
 
     const { port1, port2 } = new MessageChannel()
 
@@ -2156,14 +2160,14 @@ export class Runtime extends EventEmitter {
 
     this.#config.applications.find(s => s.id === applicationId).workers = workers
     const application = await this.#getApplicationById(applicationId)
-    this.#workers.setCount(applicationId, workers)
     application[kConfig].workers = workers
 
+    const workersIds = this.#workers.getKeys(applicationId)
     const promises = []
-    for (const [workerId, worker] of this.#workers.entries()) {
-      if (workerId.startsWith(`${applicationId}:`)) {
-        promises.push(sendViaITC(worker, 'updateWorkersCount', { applicationId, workers }))
-      }
+
+    for (const workerId of workersIds) {
+      const worker = this.#workers.get(workerId)
+      promises.push(sendViaITC(worker, 'updateWorkersCount', { applicationId, workers }))
     }
 
     const results = await Promise.allSettled(promises)
@@ -2391,7 +2395,7 @@ export class Runtime extends EventEmitter {
           `Restarting application "${applicationId}" worker ${i} to update config health heap...`
         )
 
-        const worker = await this.#getWorkerById(applicationId, i)
+        const worker = await this.#getWorkerByIdOrNext(applicationId, i)
         if (health.maxHeapTotal) {
           worker[kConfig].health.maxHeapTotal = health.maxHeapTotal
         }
@@ -2423,30 +2427,29 @@ export class Runtime extends EventEmitter {
   }
 
   async #updateApplicationWorkers (applicationId, config, applicationConfig, workers, currentWorkers) {
-    const report = {
-      current: currentWorkers,
-      new: workers
-    }
+    const report = { current: currentWorkers, new: workers }
+
+    let startedWorkersCount = 0
+    let stoppedWorkersCount = 0
+
     if (currentWorkers < workers) {
       report.started = []
       try {
-        await this.#updateApplicationConfigWorkers(applicationId, workers)
         for (let i = currentWorkers; i < workers; i++) {
           await this.#setupWorker(config, applicationConfig, workers, applicationId, i)
           await this.#startWorker(config, applicationConfig, workers, applicationId, i, false, 0)
           report.started.push(i)
+          startedWorkersCount++
         }
         report.success = true
       } catch (err) {
-        if (report.started.length < 1) {
+        if (startedWorkersCount < 1) {
           this.logger.error({ err }, 'Cannot start application workers, no worker started')
-          await this.#updateApplicationConfigWorkers(applicationId, currentWorkers)
         } else {
           this.logger.error(
             { err },
-            `Cannot start application workers, started workers: ${report.started.length} out of ${workers}`
+            `Cannot start application workers, started workers: ${startedWorkersCount} out of ${workers}`
           )
-          await this.#updateApplicationConfigWorkers(applicationId, currentWorkers + report.started.length)
         }
         report.success = false
       }
@@ -2455,26 +2458,31 @@ export class Runtime extends EventEmitter {
       report.stopped = []
       try {
         for (let i = currentWorkers - 1; i >= workers; i--) {
-          const worker = await this.#getWorkerById(applicationId, i, false, false)
+          const worker = await this.#getWorkerByIdOrNext(applicationId, i, false, false)
           await sendViaITC(worker, 'removeFromMesh')
           await this.#stopWorker(currentWorkers, applicationId, i, false, worker, [])
           report.stopped.push(i)
+          stoppedWorkersCount++
         }
-        await this.#updateApplicationConfigWorkers(applicationId, workers)
         report.success = true
       } catch (err) {
-        if (report.stopped.length < 1) {
+        if (stoppedWorkersCount < 1) {
           this.logger.error({ err }, 'Cannot stop application workers, no worker stopped')
         } else {
           this.logger.error(
             { err },
-            `Cannot stop application workers, stopped workers: ${report.stopped.length} out of ${workers}`
+            `Cannot stop application workers, stopped workers: ${stoppedWorkersCount} out of ${workers}`
           )
-          await this.#updateApplicationConfigWorkers(applicationId, currentWorkers - report.stopped)
         }
         report.success = false
       }
     }
+
+    const newWorkersCount = currentWorkers + startedWorkersCount - stoppedWorkersCount
+    if (newWorkersCount !== currentWorkers) {
+      await this.#updateApplicationConfigWorkers(applicationId, newWorkersCount)
+    }
+
     return report
   }
 
@@ -2599,7 +2607,11 @@ export class Runtime extends EventEmitter {
         }
 
         try {
-          const health = await this.#getHealth(worker)
+          const health = await this.#getHealth(worker, {
+            previousELU: worker[kLastVerticalScalerELU]
+          })
+          worker[kLastVerticalScalerELU] = health.currentELU
+
           if (!health) continue
 
           scalingAlgorithm.addWorkerHealthInfo({

package/lib/worker/controller.js

@@ -26,10 +26,7 @@ function fetchApplicationUrl (application, key) {
 }
 
 function handleUnhandled (app, type, err) {
-  const label =
-    workerData.worker.count > 1
-      ? `worker ${workerData.worker.index} of the application "${workerData.applicationConfig.id}"`
-      : `application "${workerData.applicationConfig.id}"`
+  const label = `worker ${workerData.worker.index} of the application "${workerData.applicationConfig.id}"`
 
   globalThis.platformatic.logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${type}.`)
 
@@ -160,12 +157,13 @@ export class Controller extends EventEmitter {
       this.#logAndThrow(err)
     }
 
-    this.emit('starting')
-
     if (this.capability.status === 'stopped') {
       return
     }
 
+    this.capability.updateStatus('starting')
+    this.emit('starting')
+
     if (this.#watch) {
       const watchConfig = await this.capability.getWatchConfig()
 
@@ -187,6 +185,9 @@ export class Controller extends EventEmitter {
       this.#listening = listen
       /* c8 ignore next 5 */
     } catch (err) {
+      this.capability.updateStatus('start:error')
+      this.emit('start:error', err)
+
       this.capability.log({ message: err.message, level: 'debug' })
       this.#starting = false
       throw err
@@ -194,6 +195,8 @@ export class Controller extends EventEmitter {
 
     this.#started = true
     this.#starting = false
+
+    this.capability.updateStatus('started')
     this.emit('started')
   }
 
@@ -203,6 +206,10 @@ export class Controller extends EventEmitter {
     }
 
     this.emit('stopping')
+    // Do not update status of the capability to "stopping" here otherwise
+    // if stop is called before start is finished, the capability will not
+    // be able to wait for start to finish and it will create a race condition.
+
     await this.#stopFileWatching()
     await this.capability.waitForDependentsStop(dependents)
     await this.capability.stop()
@@ -210,6 +217,8 @@ export class Controller extends EventEmitter {
     this.#started = false
     this.#starting = false
     this.#listening = false
+
+    this.capability.updateStatus('stopped')
     this.emit('stopped')
   }
 

package/lib/worker/main.js

@@ -59,13 +59,10 @@ function createLogger () {
   const pinoOptions = {
     level: 'trace',
     name: workerData.applicationConfig.id,
+    base: { pid: process.pid, hostname: hostname(), worker: workerData.worker.index },
     ...workerData.config.logger
   }
 
-  if (workerData.worker?.count > 1) {
-    pinoOptions.base = { pid: process.pid, hostname: hostname(), worker: workerData.worker.index }
-  }
-
   if (pinoOptions.formatters) {
     pinoOptions.formatters = buildPinoFormatters(pinoOptions.formatters)
   }
@@ -167,7 +164,7 @@ async function main () {
   const controller = new Controller(
     runtimeConfig,
     applicationConfig,
-    workerData.worker.count > 1 ? workerData.worker.index : undefined,
+    workerData.worker.index,
     serverConfig,
     metricsConfig
   )

package/lib/worker/messaging.js

@@ -179,12 +179,8 @@ export class MessagingITC extends ITC {
     // Create a brand new map
     this.#workers = new RoundRobinMap()
 
-    const instances = []
     for (const [application, workers] of event.data) {
       const count = workers.length
-      const next = Math.floor(Math.random() * count)
-
-      instances.push({ id: application, next, workers: count })
 
       for (let i = 0; i < count; i++) {
         const worker = workers[i]
@@ -194,8 +190,6 @@ export class MessagingITC extends ITC {
         this.#workers.set(`${application}:${i}`, { ...worker, channel })
       }
     }
-
-    this.#workers.configure(instances)
   }
 
   async #handleNotification (messageEvent) {

package/lib/worker/round-robin-map.js

@@ -1,62 +1,60 @@
 export class RoundRobinMap extends Map {
   #instances
 
-  constructor (iterable, instances = {}) {
-    super(iterable)
-    this.#instances = instances
-  }
-
-  get configuration () {
-    return { ...this.#instances }
+  constructor () {
+    super()
+    this.#instances = {}
   }
 
-  configure (applications) {
-    this.#instances = {}
+  set (key, worker) {
+    const hasKey = super.has(key)
+    if (!hasKey) {
+      const application = key.split(':')[0]
 
-    for (const application of applications) {
-      this.#instances[application.id] = { next: application.next ?? 0, count: application.workers }
+      if (!this.#instances[application]) {
+        this.#instances[application] = { keys: [] }
+      }
+      this.#instances[application].next = null
+      this.#instances[application].keys.push(key)
     }
+
+    return super.set(key, worker)
   }
 
-  getCount (application) {
-    if (!this.#instances[application]) {
-      return null
+  delete (key) {
+    const removed = super.delete(key)
+
+    if (removed) {
+      const application = key.split(':')[0]
+
+      if (this.#instances[application]) {
+        const keys = this.#instances[application].keys
+        if (keys.length <= 1) {
+          delete this.#instances[application]
+        } else {
+          const keys = this.#instances[application].keys
+          keys.splice(keys.indexOf(key), 1)
+          this.#instances[application].next = null
+        }
+      }
     }
 
-    return this.#instances[application].count
+    return removed
   }
 
-  setCount (application, count) {
-    if (!this.#instances[application]) {
-      throw new Error(`Application ${application} is not configured.`)
-    }
-
-    this.#instances[application].count = count
+  getKeys (application) {
+    return this.#instances[application]?.keys ?? []
   }
 
   next (application) {
-    if (!this.#instances[application]) {
-      return null
-    }
+    if (!this.#instances[application]) return
 
-    let worker
-    let { next, count } = this.#instances[application]
-
-    // Try count times to get the next worker. This is to handle the case where a worker is being restarted.
-    for (let i = 0; i < count; i++) {
-      const current = next++
-      if (next >= count) {
-        next = 0
-      }
-
-      worker = this.get(`${application}:${current}`)
-
-      if (worker) {
-        break
-      }
+    let { next, keys } = this.#instances[application]
+    if (next === null) {
+      next = Math.floor(Math.random() * keys.length)
     }
+    this.#instances[application].next = (next + 1) % keys.length
 
-    this.#instances[application].next = next
-    return worker
+    return this.get(keys[next])
   }
 }

package/lib/worker/symbols.js

@@ -8,7 +8,8 @@ export const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer
 export const kWorkerStatus = Symbol('plt.runtime.worker.status')
 export const kWorkerStartTime = Symbol.for('plt.runtime.worker.startTime')
 export const kInterceptors = Symbol.for('plt.runtime.worker.interceptors')
-export const kLastELU = Symbol.for('plt.runtime.worker.lastELU')
+export const kLastHealthCheckELU = Symbol.for('plt.runtime.worker.lastHealthCheckELU')
+export const kLastVerticalScalerELU = Symbol.for('plt.runtime.worker.lastVerticalScalerELU')
 
 // This string marker should be safe to use since it belongs to Unicode private area
 export const kStderrMarker = '\ue002'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.12.0",
+  "version": "3.13.1",
   "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/composer": "3.12.0",
-    "@platformatic/db": "3.12.0",
-    "@platformatic/node": "3.12.0",
-    "@platformatic/gateway": "3.12.0",
-    "@platformatic/sql-graphql": "3.12.0",
-    "@platformatic/service": "3.12.0",
-    "@platformatic/sql-mapper": "3.12.0",
-    "@platformatic/wattpm-pprof-capture": "3.12.0"
+    "@platformatic/composer": "3.13.1",
+    "@platformatic/db": "3.13.1",
+    "@platformatic/gateway": "3.13.1",
+    "@platformatic/node": "3.13.1",
+    "@platformatic/service": "3.13.1",
+    "@platformatic/sql-graphql": "3.13.1",
+    "@platformatic/sql-mapper": "3.13.1",
+    "@platformatic/wattpm-pprof-capture": "3.13.1"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -73,12 +73,12 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.15.0",
     "ws": "^8.16.0",
-    "@platformatic/foundation": "3.12.0",
-    "@platformatic/generators": "3.12.0",
-    "@platformatic/basic": "3.12.0",
-    "@platformatic/itc": "3.12.0",
-    "@platformatic/metrics": "3.12.0",
-    "@platformatic/telemetry": "3.12.0"
+    "@platformatic/basic": "3.13.1",
+    "@platformatic/generators": "3.13.1",
+    "@platformatic/foundation": "3.13.1",
+    "@platformatic/telemetry": "3.13.1",
+    "@platformatic/itc": "3.13.1",
+    "@platformatic/metrics": "3.13.1"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.12.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.13.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",