@platformatic/runtime 3.13.0 → 3.14.0

package/lib/scaling-algorithm.js

@@ -1,23 +1,28 @@
-class ScalingAlgorithm {
-  #scaleUpELU
-  #scaleDownELU
+export const scaleUpELUThreshold = 0.8
+export const scaleDownELUThreshold = 0.2
+export const scaleUpTimeWindow = 10_000
+export const scaleDownTimeWindow = 60_000
+
+export class ScalingAlgorithm {
   #maxTotalWorkers
-  #scaleUpTimeWindowSec
-  #scaleDownTimeWindowSec
   #appsMetrics
   #appsConfigs
 
   constructor (options = {}) {
-    this.#scaleUpELU = options.scaleUpELU ?? 0.8
-    this.#scaleDownELU = options.scaleDownELU ?? 0.2
     this.#maxTotalWorkers = options.maxTotalWorkers ?? Infinity
-    this.#scaleUpTimeWindowSec = options.scaleUpTimeWindowSec ?? 10
-    this.#scaleDownTimeWindowSec = options.scaleDownTimeWindowSec ?? 60
     this.#appsConfigs = options.applications ?? {}
-
     this.#appsMetrics = {}
   }
 
+  addApplication (id, config) {
+    this.#appsConfigs[id] = config
+  }
+
+  removeApplication (id) {
+    delete this.#appsConfigs[id]
+    delete this.#appsMetrics[id]
+  }
+
   addWorkerHealthInfo (healthInfo) {
     const { workerId, applicationId, elu, heapUsed } = healthInfo
     const timestamp = Date.now()
@@ -50,7 +55,7 @@ class ScalingAlgorithm {
       appsInfo.push({
         applicationId,
         workersCount,
-        avgHeapUsed: heapUsed,
+        avgHeapUsed: heapUsed
       })
 
       totalWorkersCount += workersCount
@@ -112,9 +117,7 @@ class ScalingAlgorithm {
         if (workersCount >= appMaxWorkers) continue
         if (avgHeapUsed >= totalAvailableMemory) continue
 
-        const isScaled = recommendations.some(
-          r => r.applicationId === applicationId
-        )
+        const isScaled = recommendations.some(r => r.applicationId === applicationId)
         if (isScaled) continue
 
         const recommendation = this.#getApplicationScaleRecommendation(applicationId)
@@ -122,10 +125,8 @@ class ScalingAlgorithm {
 
         if (
           !scaleUpCandidate ||
-          (recommendation.scaleUpELU > scaleUpCandidate.scaleUpELU) ||
-          (recommendation.scaleUpELU === scaleUpCandidate.scaleUpELU &&
-            workersCount < scaleUpCandidate.workersCount
-          )
+          recommendation.scaleUpELU > scaleUpCandidate.scaleUpELU ||
+          (recommendation.scaleUpELU === scaleUpCandidate.scaleUpELU && workersCount < scaleUpCandidate.workersCount)
         ) {
           scaleUpCandidate = {
             applicationId,
@@ -186,8 +187,8 @@ class ScalingAlgorithm {
       count++
     }
 
-    const elu = Math.round(eluSum / count * 100) / 100
-    const heapUsed = Math.round(heapUsedSum / count * 100) / 100
+    const elu = Math.round((eluSum / count) * 100) / 100
+    const heapUsed = Math.round((heapUsedSum / count) * 100) / 100
     return { elu, heapUsed }
   }
 
@@ -226,28 +227,22 @@ class ScalingAlgorithm {
   }
 
   #getMetricsTimeWindow () {
-    return Math.max(this.#scaleUpTimeWindowSec, this.#scaleDownTimeWindowSec) * 1000
+    return Math.max(scaleUpTimeWindow, scaleDownTimeWindow) * 1000
   }
 
   #getApplicationScaleRecommendation (applicationId) {
-    const { elu: scaleUpELU } = this.#calculateAppAvgMetrics(applicationId, {
-      timeWindow: this.#scaleUpTimeWindowSec * 1000
-    })
-    const { elu: scaleDownELU } = this.#calculateAppAvgMetrics(applicationId, {
-      timeWindow: this.#scaleDownTimeWindowSec * 1000
-    })
+    const { elu: scaleUpELU } = this.#calculateAppAvgMetrics(applicationId, { timeWindow: scaleUpTimeWindow })
+    const { elu: scaleDownELU } = this.#calculateAppAvgMetrics(applicationId, { timeWindow: scaleDownTimeWindow })
     const { heapUsed: avgHeapUsage } = this.#calculateAppAvgMetrics(applicationId)
 
     let recommendation = null
-    if (scaleUpELU > this.#scaleUpELU) {
+    if (scaleUpELU > scaleUpELUThreshold) {
       recommendation = 'scaleUp'
     }
-    if (scaleDownELU < this.#scaleDownELU) {
+    if (scaleDownELU < scaleDownELUThreshold) {
       recommendation = 'scaleDown'
     }
 
     return { recommendation, scaleUpELU, scaleDownELU, avgHeapUsage }
   }
 }
-
-export default ScalingAlgorithm

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}.`)
 
@@ -164,7 +161,7 @@ export class Controller extends EventEmitter {
       return
     }
 
-    this.capability.updateStatus('starting')
+    this.#updateCapabilityStatus('starting')
     this.emit('starting')
 
     if (this.#watch) {
@@ -188,7 +185,7 @@ export class Controller extends EventEmitter {
       this.#listening = listen
       /* c8 ignore next 5 */
     } catch (err) {
-      this.capability.updateStatus('start:error')
+      this.#updateCapabilityStatus('start:error')
       this.emit('start:error', err)
 
       this.capability.log({ message: err.message, level: 'debug' })
@@ -199,7 +196,7 @@ export class Controller extends EventEmitter {
     this.#started = true
     this.#starting = false
 
-    this.capability.updateStatus('started')
+    this.#updateCapabilityStatus('started')
     this.emit('started')
   }
 
@@ -221,7 +218,7 @@ export class Controller extends EventEmitter {
     this.#starting = false
     this.#listening = false
 
-    this.capability.updateStatus('stopped')
+    this.#updateCapabilityStatus('stopped')
     this.emit('stopped')
   }
 
@@ -336,4 +333,14 @@ export class Controller extends EventEmitter {
       }
     })
   }
+
+  #updateCapabilityStatus (status) {
+    if (typeof this.capability.updateStatus === 'function') {
+      this.capability.updateStatus(status)
+    } else {
+      // This is horrible but needed for backward compatibility
+      this.capability.status = status
+      this.capability.emit(status)
+    }
+  }
 }

package/lib/worker/health-signals.js

@@ -0,0 +1,80 @@
+import {
+  HealthSignalMustBeObjectError,
+  HealthSignalTypeMustBeStringError
+} from '../errors.js'
+
+export class HealthSignalsQueue {
+  #size
+  #values
+
+  constructor (options = {}) {
+    this.#size = options.size ?? 100
+    this.#values = []
+  }
+
+  add (value) {
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        this.#values.push(v)
+      }
+    } else {
+      this.#values.push(value)
+    }
+    if (this.#values.length > this.#size) {
+      this.#values.splice(0, this.#values.length - this.#size)
+    }
+  }
+
+  getAll () {
+    const values = this.#values
+    this.#values = []
+    return values
+  }
+}
+
+export function initHealthSignalsApi (options = {}) {
+  const queue = new HealthSignalsQueue()
+  const timeout = options.timeout ?? 1000
+  const workerId = options.workerId
+
+  let isSending = false
+  let promise = null
+
+  async function sendHealthSignal (signal) {
+    if (typeof signal !== 'object') {
+      throw new HealthSignalMustBeObjectError()
+    }
+    if (typeof signal.type !== 'string') {
+      throw new HealthSignalTypeMustBeStringError(signal.type)
+    }
+    if (!signal.timestamp || typeof signal.timestamp !== 'number') {
+      signal.timestamp = Date.now()
+    }
+
+    queue.add(signal)
+
+    if (!isSending) {
+      isSending = true
+      promise = new Promise((resolve, reject) => {
+        setTimeout(async () => {
+          isSending = false
+          try {
+            const signals = queue.getAll()
+            await globalThis.platformatic.itc.send('sendHealthSignals', {
+              workerId,
+              signals
+            })
+          } catch (err) {
+            reject(err)
+            return
+          }
+          resolve()
+        }, timeout)
+      })
+    }
+
+    return promise
+  }
+
+  globalThis.platformatic.sendHealthSignal = sendHealthSignal
+}

package/lib/worker/main.js

@@ -20,6 +20,7 @@ import { setDispatcher } from './interceptors.js'
 import { setupITC } from './itc.js'
 import { SharedContext } from './shared-context.js'
 import { kId, kITC, kStderrMarker } from './symbols.js'
+import { initHealthSignalsApi } from './health-signals.js'
 
 class ForwardingEventEmitter extends EventEmitter {
   emitAndNotify (event, ...args) {
@@ -59,13 +60,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 +165,7 @@ async function main () {
   const controller = new Controller(
     runtimeConfig,
     applicationConfig,
-    workerData.worker.count > 1 ? workerData.worker.index : undefined,
+    workerData.worker.index,
     serverConfig,
     metricsConfig
   )
@@ -193,6 +191,11 @@ async function main () {
   globalThis[kITC] = itc
   globalThis.platformatic.itc = itc
 
+  initHealthSignalsApi({
+    workerId: workerData.worker.id,
+    applicationId: applicationConfig.id
+  })
+
   itc.notify('init')
 }
 

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

@@ -5,10 +5,13 @@ 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')
 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.13.0",
+  "version": "3.14.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/gateway": "3.13.0",
-    "@platformatic/db": "3.13.0",
-    "@platformatic/node": "3.13.0",
-    "@platformatic/composer": "3.13.0",
-    "@platformatic/service": "3.13.0",
-    "@platformatic/sql-graphql": "3.13.0",
-    "@platformatic/sql-mapper": "3.13.0",
-    "@platformatic/wattpm-pprof-capture": "3.13.0"
+    "@platformatic/db": "3.14.0",
+    "@platformatic/gateway": "3.14.0",
+    "@platformatic/composer": "3.14.0",
+    "@platformatic/node": "3.14.0",
+    "@platformatic/service": "3.14.0",
+    "@platformatic/sql-graphql": "3.14.0",
+    "@platformatic/sql-mapper": "3.14.0",
+    "@platformatic/wattpm-pprof-capture": "3.14.0"
   },
   "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/basic": "3.13.0",
-    "@platformatic/foundation": "3.13.0",
-    "@platformatic/generators": "3.13.0",
-    "@platformatic/itc": "3.13.0",
-    "@platformatic/metrics": "3.13.0",
-    "@platformatic/telemetry": "3.13.0"
+    "@platformatic/basic": "3.14.0",
+    "@platformatic/metrics": "3.14.0",
+    "@platformatic/foundation": "3.14.0",
+    "@platformatic/generators": "3.14.0",
+    "@platformatic/telemetry": "3.14.0",
+    "@platformatic/itc": "3.14.0"
   },
   "engines": {
     "node": ">=22.19.0"