@platformatic/runtime 3.71.1-alpha.0 → 4.0.0-alpha.1

package/lib/scaling-algorithm.js

@@ -1,256 +0,0 @@
-export const scaleUpTimeWindow = 10_000
-export const scaleDownTimeWindow = 60_000
-
-export class ScalingAlgorithm {
-  #maxTotalWorkers
-  #appsMetrics
-  #appsConfigs
-  #scaleUpELU
-  #scaleDownELU
-
-  constructor (options = {}) {
-    this.#maxTotalWorkers = options.maxTotalWorkers ?? Infinity
-    this.#appsConfigs = options.applications ?? {}
-    this.#appsMetrics = {}
-    this.#scaleUpELU = options.scaleUpELU ?? 0.8
-    this.#scaleDownELU = options.scaleDownELU ?? 0.2
-  }
-
-  addApplication (id, config = {}) {
-    config.scaleUpELU ??= this.#scaleUpELU
-    config.scaleDownELU ??= this.#scaleDownELU
-
-    this.#appsConfigs[id] = config
-    this.#appsMetrics[id] ??= {}
-  }
-
-  removeApplication (id) {
-    delete this.#appsConfigs[id]
-    delete this.#appsMetrics[id]
-  }
-
-  addWorkerHealthInfo (healthInfo) {
-    const { workerId, applicationId, elu, heapUsed } = healthInfo
-    const timestamp = Date.now()
-
-    if (!this.#appsMetrics[applicationId]) {
-      throw new Error(`Missing application "${applicationId}" in the scaling algorithm.`)
-    }
-
-    if (!this.#appsMetrics[applicationId][workerId]) {
-      this.#appsMetrics[applicationId][workerId] = []
-    }
-    this.#appsMetrics[applicationId][workerId].push({
-      elu,
-      timestamp,
-      heapUsed
-    })
-    this.#removeOutdatedAppELUs(applicationId)
-  }
-
-  getRecommendations (appsWorkersInfo, options = {}) {
-    let totalWorkersCount = 0
-    let totalAvailableMemory = options.availableMemory ?? Infinity
-
-    const appsInfo = []
-
-    for (const applicationId in appsWorkersInfo) {
-      const workersCount = appsWorkersInfo[applicationId]
-
-      const { heapUsed } = this.#calculateAppAvgMetrics(applicationId)
-
-      appsInfo.push({
-        applicationId,
-        workersCount,
-        avgHeapUsed: heapUsed
-      })
-
-      totalWorkersCount += workersCount
-    }
-
-    const recommendations = []
-
-    for (const { applicationId, workersCount, avgHeapUsed } of appsInfo) {
-      const appMinWorkers = this.#appsConfigs[applicationId]?.minWorkers ?? 1
-      const appMaxWorkers = this.#appsConfigs[applicationId]?.maxWorkers ?? this.#maxTotalWorkers
-
-      if (workersCount < appMinWorkers) {
-        recommendations.push({
-          applicationId,
-          workersCount: appMinWorkers,
-          direction: 'up'
-        })
-
-        const newWorkersCount = appMinWorkers - workersCount
-        totalWorkersCount += newWorkersCount
-        totalAvailableMemory -= newWorkersCount * avgHeapUsed
-        continue
-      }
-
-      if (workersCount > appMaxWorkers) {
-        recommendations.push({
-          applicationId,
-          workersCount: appMaxWorkers,
-          direction: 'down'
-        })
-
-        const removedWorkersCount = workersCount - appMaxWorkers
-        totalWorkersCount -= removedWorkersCount
-        totalAvailableMemory += removedWorkersCount * avgHeapUsed
-        continue
-      }
-
-      if (workersCount > appMinWorkers) {
-        const recommendation = this.#getApplicationScaleRecommendation(applicationId)
-        if (recommendation.recommendation === 'scaleDown') {
-          recommendations.push({
-            applicationId,
-            workersCount: workersCount - 1,
-            direction: 'down'
-          })
-
-          const removedWorkersCount = 1
-          totalWorkersCount -= removedWorkersCount
-          totalAvailableMemory += removedWorkersCount * avgHeapUsed
-        }
-      }
-    }
-
-    if (totalWorkersCount < this.#maxTotalWorkers) {
-      let scaleUpCandidate = null
-
-      for (const { applicationId, workersCount, avgHeapUsed } of appsInfo) {
-        const appMaxWorkers = this.#appsConfigs[applicationId]?.maxWorkers ?? this.#maxTotalWorkers
-        if (workersCount >= appMaxWorkers) continue
-        if (avgHeapUsed >= totalAvailableMemory) continue
-
-        const isScaled = recommendations.some(r => r.applicationId === applicationId)
-        if (isScaled) continue
-
-        const recommendation = this.#getApplicationScaleRecommendation(applicationId)
-        if (recommendation.recommendation !== 'scaleUp') continue
-
-        if (
-          !scaleUpCandidate ||
-          recommendation.scaleUpELU > scaleUpCandidate.scaleUpELU ||
-          (recommendation.scaleUpELU === scaleUpCandidate.scaleUpELU && workersCount < scaleUpCandidate.workersCount)
-        ) {
-          scaleUpCandidate = {
-            applicationId,
-            workersCount,
-            heapUsed: recommendation.avgHeapUsage,
-            elu: recommendation.scaleUpELU
-          }
-        }
-      }
-
-      if (scaleUpCandidate) {
-        recommendations.push({
-          applicationId: scaleUpCandidate.applicationId,
-          workersCount: scaleUpCandidate.workersCount + 1,
-          direction: 'up'
-        })
-        totalWorkersCount++
-        totalAvailableMemory -= scaleUpCandidate.heapUsed
-      }
-    }
-
-    return recommendations
-  }
-
-  #calculateAppAvgMetrics (applicationId, options = {}) {
-    this.#removeOutdatedAppELUs(applicationId)
-
-    const appMetrics = this.#appsMetrics[applicationId]
-    if (!appMetrics) return { elu: 0, heapUsed: 0 }
-
-    const defaultTimeWindow = this.#getMetricsTimeWindow()
-    const timeWindow = options.timeWindow ?? defaultTimeWindow
-
-    let eluSum = 0
-    let heapUsedSum = 0
-    let count = 0
-
-    const now = Date.now()
-
-    for (const workerId in appMetrics) {
-      const workerMetrics = appMetrics[workerId]
-
-      let workerELUSum = 0
-      let workerHeapUsedSum = 0
-      let metricCount = 0
-
-      for (const metric of workerMetrics) {
-        if (metric.timestamp < now - timeWindow) continue
-        workerELUSum += metric.elu
-        workerHeapUsedSum += metric.heapUsed
-        metricCount++
-      }
-
-      if (metricCount === 0) continue
-
-      eluSum += workerELUSum / metricCount
-      heapUsedSum += workerHeapUsedSum / metricCount
-      count++
-    }
-
-    const elu = Math.round((eluSum / count) * 100) / 100
-    const heapUsed = Math.round((heapUsedSum / count) * 100) / 100
-    return { elu, heapUsed }
-  }
-
-  #removeOutdatedAppELUs (applicationId) {
-    const appELUs = this.#appsMetrics[applicationId]
-    if (!appELUs) return
-
-    const now = Date.now()
-    const timeWindow = this.#getMetricsTimeWindow()
-
-    for (const workerId in appELUs) {
-      const workerELUs = appELUs[workerId]
-
-      let firstValidIndex = -1
-      for (let i = 0; i < workerELUs.length; i++) {
-        const timestamp = workerELUs[i].timestamp
-        if (timestamp >= now - timeWindow) {
-          firstValidIndex = i
-          break
-        }
-      }
-
-      if (firstValidIndex > 0) {
-        // Remove all outdated entries before the first valid one
-        workerELUs.splice(0, firstValidIndex)
-      } else if (firstValidIndex === -1) {
-        // All entries are outdated, clear the array
-        workerELUs.length = 0
-      }
-
-      // If there are no more workerELUs, remove the workerId
-      if (workerELUs.length === 0) {
-        delete appELUs[workerId]
-      }
-    }
-  }
-
-  #getMetricsTimeWindow () {
-    return Math.max(scaleUpTimeWindow, scaleDownTimeWindow) * 1000
-  }
-
-  #getApplicationScaleRecommendation (applicationId) {
-    const { elu: scaleUpELU } = this.#calculateAppAvgMetrics(applicationId, { timeWindow: scaleUpTimeWindow })
-    const { elu: scaleDownELU } = this.#calculateAppAvgMetrics(applicationId, { timeWindow: scaleDownTimeWindow })
-    const { heapUsed: avgHeapUsage } = this.#calculateAppAvgMetrics(applicationId)
-    const config = this.#appsConfigs[applicationId]
-
-    let recommendation = null
-    if (scaleUpELU > config.scaleUpELU) {
-      recommendation = 'scaleUp'
-    }
-    if (scaleDownELU < config.scaleDownELU) {
-      recommendation = 'scaleDown'
-    }
-
-    return { recommendation, scaleUpELU, scaleDownELU, avgHeapUsage }
-  }
-}

package/lib/worker-scaler.js

@@ -1,249 +0,0 @@
-import { features } from '@platformatic/foundation'
-import { availableParallelism } from 'node:os'
-import { getMemoryInfo } from './metrics.js'
-import { ScalingAlgorithm } from './scaling-algorithm.js'
-import { kApplicationId, kId, kLastWorkerScalerELU, kWorkerStartTime, kWorkerStatus } from './worker/symbols.js'
-
-const healthCheckInterval = 1000
-export const kOriginalWorkers = Symbol('plt.runtime.application.dynamicWorkersScalerOriginalWorkers')
-
-const defaultCooldown = 20_000
-const defaultGracePeriod = 30_000
-const scaleIntervalPeriod = 60_000
-
-export class DynamicWorkersScaler {
-  #status
-  #runtime
-  #algorithm
-
-  #maxTotalMemory
-  #maxTotalWorkers
-  #maxWorkers
-  #minWorkers
-  #scaleUpELU
-  #scaleDownELU
-  #cooldown
-  #gracePeriod
-
-  #initialUpdates
-  #memoryInfo
-  #healthCheckTimeout
-  #checkScalingInterval
-  #isScaling
-  #lastScaling
-  #appsConfigs
-
-  constructor (runtime, config) {
-    this.#runtime = runtime
-
-    this.#maxTotalMemory = config.maxMemory // This is defaulted in start()
-    this.#maxTotalWorkers = config.total ?? availableParallelism()
-    this.#maxWorkers = config.maximum ?? this.#maxTotalWorkers
-    this.#minWorkers = config.minimum ?? 1
-    this.#scaleUpELU = config.scaleUpELU ?? 0.8
-    this.#scaleDownELU = config.scaleDownELU ?? 0.2
-    this.#cooldown = config.cooldown ?? defaultCooldown
-    this.#gracePeriod = config.gracePeriod ?? defaultGracePeriod
-
-    this.#algorithm = new ScalingAlgorithm({
-      maxTotalWorkers: this.#maxTotalWorkers,
-      scaleUpELU: this.#scaleUpELU,
-      scaleDownELU: this.#scaleDownELU
-    })
-
-    this.#isScaling = false
-    this.#lastScaling = 0
-    this.#initialUpdates = []
-    this.#status = 'init'
-    this.#appsConfigs = {}
-  }
-
-  getConfig () {
-    return {
-      maxTotalMemory: this.#maxTotalMemory,
-      maxTotalWorkers: this.#maxTotalWorkers,
-      maxWorkers: this.#maxWorkers,
-      minWorkers: this.#minWorkers,
-      cooldown: this.#cooldown,
-      gracePeriod: this.#gracePeriod
-    }
-  }
-
-  async start () {
-    this.#memoryInfo = await getMemoryInfo()
-    this.#maxTotalMemory ??= this.#memoryInfo.total * 0.9
-
-    this.#checkScalingInterval = setInterval(this.#checkScaling.bind(this), scaleIntervalPeriod)
-    this.#healthCheckTimeout = setTimeout(this.#chechHealth.bind(this), healthCheckInterval)
-
-    if (this.#initialUpdates.length > 0) {
-      await this.#runtime.updateApplicationsResources(this.#initialUpdates)
-      this.#initialUpdates = []
-    }
-
-    this.#status = 'started'
-  }
-
-  stop () {
-    clearTimeout(this.#healthCheckTimeout)
-    clearInterval(this.#checkScalingInterval)
-    this.#status = 'stopped'
-  }
-
-  async add (application) {
-    const config = {}
-
-    if (application.entrypoint && !features.node.reusePort) {
-      this.#runtime.logger.warn(
-        `The "${application.id}" application cannot be scaled because it is an entrypoint and the "reusePort" feature is not available in your OS.`
-      )
-
-      config.minWorkers = 1
-      config.maxWorkers = 1
-    } else if (application.workers.dynamic === false) {
-      this.#runtime.logger.warn(
-        `The "${application.id}" application cannot be scaled because it has a fixed number of workers (${application.workers.static}).`
-      )
-
-      config.minWorkers = application.workers.static
-      config.maxWorkers = application.workers.static
-    } else {
-      config.minWorkers = application.workers.minimum
-      config.maxWorkers = application.workers.maximum
-      config.scaleUpELU = application.workers.scaleUpELU
-      config.scaleDownELU = application.workers.scaleDownELU
-    }
-
-    config.minWorkers ??= this.#minWorkers
-    config.maxWorkers ??= this.#maxWorkers
-    config.scaleUpELU ??= this.#scaleUpELU
-    config.scaleDownELU ??= this.#scaleDownELU
-
-    if (config.minWorkers > 1) {
-      const update = { application: application.id, workers: config.minWorkers }
-      this.#initialUpdates.push(update)
-    }
-
-    this.#appsConfigs[application.id] = config
-    this.#algorithm.addApplication(application.id, config)
-  }
-
-  async applyPendingUpdate (applicationId) {
-    if (this.#status !== 'started') {
-      return
-    }
-
-    const update = this.#initialUpdates.find(update => update.application === applicationId)
-    if (!update) {
-      return
-    }
-
-    await this.#runtime.updateApplicationsResources([update])
-    this.#initialUpdates = this.#initialUpdates.filter(pending => pending !== update)
-  }
-
-  remove (applicationId) {
-    delete this.#appsConfigs[applicationId]
-    this.#initialUpdates = this.#initialUpdates.filter(update => update.application !== applicationId)
-    this.#algorithm.removeApplication(applicationId)
-  }
-
-  async #chechHealth () {
-    let shouldCheckForScaling = false
-
-    const now = Date.now()
-
-    const workers = await this.#runtime.getWorkers(true)
-
-    for (const { raw: worker } of Object.values(workers)) {
-      if (worker[kWorkerStatus] !== 'started' || worker[kWorkerStartTime] + this.#gracePeriod > now) {
-        continue
-      }
-
-      try {
-        const health = await this.#runtime.getWorkerHealth(worker, { previousELU: worker[kLastWorkerScalerELU] })
-
-        if (!health) {
-          continue
-        }
-
-        worker[kLastWorkerScalerELU] = health.currentELU
-
-        const workerId = worker[kId]
-        const applicationId = worker[kApplicationId]
-        const scaleConfig = this.#appsConfigs[applicationId]
-        if (!scaleConfig) continue
-
-        this.#algorithm.addWorkerHealthInfo({
-          workerId,
-          applicationId,
-          elu: health.elu,
-          heapUsed: health.heapUsed,
-          heapTotal: health.heapTotal
-        })
-
-        if (health.elu > scaleConfig.scaleUpELU) {
-          shouldCheckForScaling = true
-        }
-      } catch (err) {
-        this.#runtime.logger.error({ err }, 'Failed to get health for worker')
-      }
-    }
-
-    if (shouldCheckForScaling) {
-      await this.#checkScaling()
-    }
-
-    this.#healthCheckTimeout.refresh()
-  }
-
-  async #checkScaling () {
-    const isInCooldown = Date.now() < this.#lastScaling + this.#cooldown
-    if (this.#isScaling || isInCooldown) {
-      return
-    }
-
-    this.#isScaling = true
-
-    try {
-      const workersInfo = await this.#runtime.getWorkers()
-      const mem = await getMemoryInfo({ scope: this.#memoryInfo.scope })
-
-      const appsWorkersInfo = {}
-      for (const worker of Object.values(workersInfo)) {
-        if (worker.status === 'exited') {
-          continue
-        }
-
-        const applicationId = worker.application
-        appsWorkersInfo[applicationId] ??= 0
-        appsWorkersInfo[applicationId]++
-      }
-
-      const availableMemory = this.#maxTotalMemory - mem.used
-      const recommendations = this.#algorithm.getRecommendations(appsWorkersInfo, { availableMemory })
-
-      if (recommendations.length > 0) {
-        await this.#applyRecommendations(recommendations)
-        this.#lastScaling = Date.now()
-      }
-    } catch (err) {
-      this.#runtime.logger.error({ err }, 'Failed to scale applications')
-    } finally {
-      this.#isScaling = false
-    }
-  }
-
-  async #applyRecommendations (recommendations) {
-    const resourcesUpdates = []
-
-    for (const recommendation of recommendations) {
-      const { applicationId, workersCount, direction } = recommendation
-      this.#runtime.logger.info(`Scaling ${direction} the "${applicationId}" app to ${workersCount} workers`)
-
-      resourcesUpdates.push({ application: applicationId, workers: workersCount })
-    }
-
-    return this.#runtime.updateApplicationsResources(resourcesUpdates)
-  }
-}