@platformatic/runtime 3.7.1 → 3.9.0

package/config.d.ts

@@ -332,6 +332,24 @@ export type PlatformaticRuntimeConfig = {
           [k: string]: unknown;
         };
   };
+  verticalScaler?: {
+    enabled?: boolean;
+    maxTotalWorkers?: number;
+    minWorkers?: number;
+    maxWorkers?: number;
+    scaleUpELU?: number;
+    scaleDownELU?: number;
+    minELUDiff?: number;
+    timeWindowSec?: number;
+    cooldownSec?: number;
+    scaleIntervalSec?: number;
+    applications?: {
+      [k: string]: {
+        minWorkers?: number;
+        maxWorkers?: number;
+      };
+    };
+  };
   inspectorOptions?: {
     host?: string;
     port?: number;

package/lib/management-api.js

@@ -126,7 +126,8 @@ export async function managementApiPlugin (app, opts) {
     const { id } = request.params
     app.log.debug('stop profiling', { id })
 
-    const profileData = await runtime.stopApplicationProfiling(id)
+    const options = request.body || {}
+    const profileData = await runtime.stopApplicationProfiling(id, options)
     reply.type('application/octet-stream').code(200).send(profileData)
   })
 

package/lib/runtime.js

@@ -9,6 +9,7 @@ import {
   kTimeout,
   parseMemorySize
 } from '@platformatic/foundation'
+import os from 'node:os'
 import { ITC } from '@platformatic/itc'
 import fastify from 'fastify'
 import { EventEmitter, once } from 'node:events'
@@ -44,6 +45,7 @@ import { createSharedStore } from './shared-http-cache.js'
 import { version } from './version.js'
 import { sendViaITC, waitEventFromITC } from './worker/itc.js'
 import { RoundRobinMap } from './worker/round-robin-map.js'
+import ScalingAlgorithm from './scaling-algorithm.js'
 import {
   kApplicationId,
   kConfig,
@@ -179,7 +181,7 @@ export class Runtime extends EventEmitter {
 
     const workersConfig = []
     for (const application of config.applications) {
-      const count = application.workers ?? this.#config.workers
+      const 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}`
@@ -274,6 +276,10 @@ export class Runtime extends EventEmitter {
       this.startCollectingMetrics()
     }
 
+    if (this.#config.verticalScaler?.enabled) {
+      this.#setupVerticalScaler()
+    }
+
     this.#showUrl()
     return this.#url
   }
@@ -556,11 +562,11 @@ export class Runtime extends EventEmitter {
     return sendViaITC(service, 'startProfiling', options)
   }
 
-  async stopApplicationProfiling (id, ensureStarted = true) {
+  async stopApplicationProfiling (id, options = {}, ensureStarted = true) {
     const service = await this.#getApplicationById(id, ensureStarted)
     this.#validatePprofCapturePreload()
 
-    return sendViaITC(service, 'stopProfiling')
+    return sendViaITC(service, 'stopProfiling', options)
   }
 
   async updateUndiciInterceptors (undiciConfig) {
@@ -2434,4 +2440,138 @@ export class Runtime extends EventEmitter {
       throw new MissingPprofCapture()
     }
   }
+
+  #setupVerticalScaler () {
+    const isWorkersFixed = this.#config.workers !== undefined
+    if (isWorkersFixed) return
+
+    const scalerConfig = this.#config.verticalScaler
+
+    scalerConfig.maxTotalWorkers ??= os.availableParallelism()
+    scalerConfig.maxWorkers ??= scalerConfig.maxTotalWorkers
+    scalerConfig.minWorkers ??= 1
+    scalerConfig.cooldownSec ??= 60
+    scalerConfig.scaleUpELU ??= 0.8
+    scalerConfig.scaleDownELU ??= 0.2
+    scalerConfig.minELUDiff ??= 0.2
+    scalerConfig.scaleIntervalSec ??= 60
+    scalerConfig.timeWindowSec ??= 60
+    scalerConfig.applications ??= {}
+
+    const maxTotalWorkers = scalerConfig.maxTotalWorkers
+    const maxWorkers = scalerConfig.maxWorkers
+    const minWorkers = scalerConfig.minWorkers
+    const cooldown = scalerConfig.cooldownSec
+    const scaleUpELU = scalerConfig.scaleUpELU
+    const scaleDownELU = scalerConfig.scaleDownELU
+    const minELUDiff = scalerConfig.minELUDiff
+    const scaleIntervalSec = scalerConfig.scaleIntervalSec
+    const timeWindowSec = scalerConfig.timeWindowSec
+    const applicationsConfigs = scalerConfig.applications
+
+    for (const application of this.#config.applications) {
+      if (application.entrypoint && !features.node.reusePort) {
+        applicationsConfigs[application.id] = {
+          minWorkers: 1,
+          maxWorkers: 1
+        }
+        continue
+      }
+      if (application.workers !== undefined) {
+        applicationsConfigs[application.id] = {
+          minWorkers: application.workers,
+          maxWorkers: application.workers
+        }
+        continue
+      }
+
+      applicationsConfigs[application.id] ??= {}
+      applicationsConfigs[application.id].minWorkers ??= minWorkers
+      applicationsConfigs[application.id].maxWorkers ??= maxWorkers
+    }
+
+    for (const applicationId in applicationsConfigs) {
+      const application = this.#config.applications.find(
+        app => app.id === applicationId
+      )
+      if (!application) {
+        delete applicationsConfigs[applicationId]
+
+        this.logger.warn(
+          `Vertical scaler configuration has a configuration for non-existing application "${applicationId}"`
+        )
+      }
+    }
+
+    const scalingAlgorithm = new ScalingAlgorithm({
+      maxTotalWorkers,
+      scaleUpELU,
+      scaleDownELU,
+      minELUDiff,
+      timeWindowSec,
+      applications: applicationsConfigs
+    })
+
+    this.on('application:worker:health', async (healthInfo) => {
+      if (!healthInfo) {
+        this.logger.error('No health info received')
+        return
+      }
+
+      scalingAlgorithm.addWorkerHealthInfo(healthInfo)
+
+      if (healthInfo.currentHealth.elu > scaleUpELU) {
+        await checkForScaling()
+      }
+    })
+
+    let isScaling = false
+    let lastScaling = 0
+
+    const checkForScaling = async () => {
+      const isInCooldown = Date.now() < lastScaling + cooldown * 1000
+      if (isScaling || isInCooldown) return
+      isScaling = true
+
+      try {
+        const workersInfo = await this.getWorkers()
+
+        const appsWorkersInfo = {}
+        for (const worker of Object.values(workersInfo)) {
+          if (worker.status === 'exited') continue
+
+          const applicationId = worker.application
+          appsWorkersInfo[applicationId] ??= 0
+          appsWorkersInfo[applicationId]++
+        }
+
+        const recommendations = scalingAlgorithm.getRecommendations(appsWorkersInfo)
+        if (recommendations.length > 0) {
+          await applyRecommendations(recommendations)
+        }
+      } catch (err) {
+        this.logger.error({ err }, 'Failed to scale applications')
+      } finally {
+        isScaling = false
+        lastScaling = Date.now()
+      }
+    }
+
+    const applyRecommendations = async (recommendations) => {
+      const resourcesUpdates = []
+      for (const recommendation of recommendations) {
+        const { applicationId, workersCount, direction } = recommendation
+        this.logger.info(`Scaling ${direction} the "${applicationId}" app to ${workersCount} workers`)
+
+        resourcesUpdates.push({
+          application: applicationId,
+          workers: workersCount
+        })
+      }
+      await this.updateApplicationsResources(resourcesUpdates)
+    }
+
+    // Interval for periodic scaling checks
+    setInterval(checkForScaling, scaleIntervalSec * 1000).unref()
+  }
 }

package/lib/scaling-algorithm.js

@@ -0,0 +1,179 @@
+class ScalingAlgorithm {
+  #scaleUpELU
+  #scaleDownELU
+  #maxTotalWorkers
+  #timeWindowSec
+  #appsELUs
+  #minELUDiff
+  #appsConfigs
+
+  constructor (options = {}) {
+    this.#scaleUpELU = options.scaleUpELU ?? 0.8
+    this.#scaleDownELU = options.scaleDownELU ?? 0.2
+    this.#maxTotalWorkers = options.maxTotalWorkers
+    this.#minELUDiff = options.minELUDiff ?? 0.2
+    this.#timeWindowSec = options.timeWindowSec ?? 60
+    this.#appsConfigs = options.applications ?? {}
+
+    this.#appsELUs = {}
+  }
+
+  addWorkerHealthInfo (healthInfo) {
+    const workerId = healthInfo.id
+    const applicationId = healthInfo.application
+    const elu = healthInfo.currentHealth.elu
+    const timestamp = Date.now()
+
+    if (!this.#appsELUs[applicationId]) {
+      this.#appsELUs[applicationId] = {}
+    }
+    if (!this.#appsELUs[applicationId][workerId]) {
+      this.#appsELUs[applicationId][workerId] = []
+    }
+    this.#appsELUs[applicationId][workerId].push({ elu, timestamp })
+    this.#removeOutdatedAppELUs(applicationId)
+  }
+
+  getRecommendations (appsWorkersInfo) {
+    let totalWorkersCount = 0
+    let appsInfo = []
+
+    for (const applicationId in appsWorkersInfo) {
+      const workersCount = appsWorkersInfo[applicationId]
+      const elu = this.#calculateAppAvgELU(applicationId)
+      appsInfo.push({ applicationId, workersCount, elu })
+      totalWorkersCount += workersCount
+    }
+
+    appsInfo = appsInfo.sort(
+      (app1, app2) => {
+        if (app1.elu > app2.elu) return 1
+        if (app1.elu < app2.elu) return -1
+        if (app1.workersCount < app2.workersCount) return 1
+        if (app1.workersCount > app2.workersCount) return -1
+        return 0
+      }
+    )
+
+    const recommendations = []
+
+    for (const { applicationId, elu, workersCount } of appsInfo) {
+      const appMinWorkers = this.#appsConfigs[applicationId]?.minWorkers ?? 1
+
+      if (elu < this.#scaleDownELU && workersCount > appMinWorkers) {
+        recommendations.push({
+          applicationId,
+          workersCount: workersCount - 1,
+          direction: 'down'
+        })
+        totalWorkersCount--
+      }
+    }
+
+    for (const scaleUpCandidate of appsInfo.toReversed()) {
+      if (scaleUpCandidate.elu < this.#scaleUpELU) break
+
+      const { applicationId, workersCount } = scaleUpCandidate
+
+      const appMaxWorkers = this.#appsConfigs[applicationId]?.maxWorkers ?? this.#maxTotalWorkers
+      if (workersCount >= appMaxWorkers) continue
+
+      if (totalWorkersCount >= this.#maxTotalWorkers) {
+        let scaleDownCandidate = null
+        for (const app of appsInfo) {
+          const appMinWorkers = this.#appsConfigs[app.applicationId]?.minWorkers ?? 1
+          if (app.workersCount > appMinWorkers) {
+            scaleDownCandidate = app
+            break
+          }
+        }
+
+        if (scaleDownCandidate) {
+          const eluDiff = scaleUpCandidate.elu - scaleDownCandidate.elu
+          const workersDiff = scaleDownCandidate.workersCount - scaleUpCandidate.workersCount
+
+          if (eluDiff >= this.#minELUDiff || workersDiff >= 2) {
+            recommendations.push({
+              applicationId: scaleDownCandidate.applicationId,
+              workersCount: scaleDownCandidate.workersCount - 1,
+              direction: 'down'
+            })
+            recommendations.push({
+              applicationId,
+              workersCount: workersCount + 1,
+              direction: 'up'
+            })
+          }
+        }
+      } else {
+        recommendations.push({
+          applicationId,
+          workersCount: workersCount + 1,
+          direction: 'up'
+        })
+        totalWorkersCount++
+      }
+      break
+    }
+
+    return recommendations
+  }
+
+  #calculateAppAvgELU (applicationId) {
+    this.#removeOutdatedAppELUs(applicationId)
+
+    const appELUs = this.#appsELUs[applicationId]
+    if (!appELUs) return 0
+
+    let eluSum = 0
+    let eluCount = 0
+
+    for (const workerId in appELUs) {
+      const workerELUs = appELUs[workerId]
+      const workerELUSum = workerELUs.reduce(
+        (sum, workerELU) => sum + workerELU.elu, 0
+      )
+      eluSum += workerELUSum / workerELUs.length
+      eluCount++
+    }
+
+    if (eluCount === 0) return 0
+
+    return Math.round(eluSum / eluCount * 100) / 100
+  }
+
+  #removeOutdatedAppELUs (applicationId) {
+    const appELUs = this.#appsELUs[applicationId]
+    if (!appELUs) return
+
+    const now = Date.now()
+
+    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 - this.#timeWindowSec * 1000) {
+          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]
+      }
+    }
+  }
+}
+
+export default ScalingAlgorithm

package/lib/schema.js

@@ -16,6 +16,18 @@ const runtimeLogger = {
 
 schemaComponents.runtimeProperties.logger = runtimeLogger
 
+schemaComponents.runtimeProperties.verticalScaler.properties.applications = {
+  type: 'object',
+  additionalProperties: {
+    type: 'object',
+    properties: {
+      minWorkers: { type: 'number', minimum: 1 },
+      maxWorkers: { type: 'number', minimum: 1 }
+    },
+    additionalProperties: false
+  }
+}
+
 const platformaticRuntimeSchema = {
   $id: `https://schemas.platformatic.dev/@platformatic/runtime/${version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',

package/lib/worker/controller.js

@@ -1,5 +1,6 @@
 import {
   ensureLoggableError,
+  executeWithTimeout,
   FileWatcher,
   kHandledError,
   listRecognizedConfigurationFiles,
@@ -24,6 +25,21 @@ function fetchApplicationUrl (application, key) {
   return getApplicationUrl(application.id)
 }
 
+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}"`
+
+  globalThis.platformatic.logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${type}.`)
+
+  executeWithTimeout(app?.stop(), 1000)
+    .catch()
+    .finally(() => {
+      process.exit(1)
+    })
+}
+
 export class Controller extends EventEmitter {
   #starting
   #started
@@ -34,21 +50,13 @@ export class Controller extends EventEmitter {
   #context
   #lastELU
 
-  constructor (
-    appConfig,
-    workerId,
-    telemetryConfig,
-    loggerConfig,
-    serverConfig,
-    metricsConfig,
-    hasManagementApi,
-    watch
-  ) {
+  constructor (runtimeConfig, applicationConfig, workerId, serverConfig, metricsConfig) {
     super()
-    this.appConfig = appConfig
-    this.applicationId = this.appConfig.id
+    this.runtimeConfig = runtimeConfig
+    this.applicationConfig = applicationConfig
+    this.applicationId = this.applicationConfig.id
     this.workerId = workerId
-    this.#watch = watch
+    this.#watch = !!runtimeConfig.watch
     this.#starting = false
     this.#started = false
     this.#listening = false
@@ -60,17 +68,17 @@ export class Controller extends EventEmitter {
       controller: this,
       applicationId: this.applicationId,
       workerId: this.workerId,
-      directory: this.appConfig.path,
-      dependencies: this.appConfig.dependencies,
-      isEntrypoint: this.appConfig.entrypoint,
-      isProduction: this.appConfig.isProduction,
-      telemetryConfig,
+      directory: this.applicationConfig.path,
+      dependencies: this.applicationConfig.dependencies,
+      isEntrypoint: this.applicationConfig.entrypoint,
+      isProduction: this.applicationConfig.isProduction,
+      telemetryConfig: this.applicationConfig.telemetry,
+      loggerConfig: runtimeConfig.logger,
       metricsConfig,
-      loggerConfig,
       serverConfig,
       worker: workerData?.worker,
-      hasManagementApi: !!hasManagementApi,
-      fetchApplicationUrl: fetchApplicationUrl.bind(null, appConfig)
+      hasManagementApi: !!runtimeConfig.managementApi,
+      fetchApplicationUrl: fetchApplicationUrl.bind(null, applicationConfig)
     }
   }
 
@@ -90,7 +98,7 @@ export class Controller extends EventEmitter {
   // Note: capability's init() is executed within start
   async init () {
     try {
-      const appConfig = this.appConfig
+      const appConfig = this.applicationConfig
 
       if (appConfig.isProduction && !process.env.NODE_ENV) {
         process.env.NODE_ENV = 'production'
@@ -120,6 +128,10 @@ export class Controller extends EventEmitter {
       }
 
       this.#updateDispatcher()
+
+      if (this.capability.exitOnUnhandledErrors && this.runtimeConfig.exitOnUnhandledErrors) {
+        this.#setupHandlers()
+      }
     } catch (err) {
       if (err.validationErrors) {
         globalThis.platformatic.logger.error(
@@ -168,7 +180,7 @@ export class Controller extends EventEmitter {
       }
     }
 
-    const listen = !!this.appConfig.useHttp
+    const listen = !!this.applicationConfig.useHttp
 
     try {
       await this.capability.start({ listen })
@@ -203,7 +215,7 @@ export class Controller extends EventEmitter {
 
   async listen () {
     // This server is not an entrypoint or already listened in start. Behave as no-op.
-    if (!this.appConfig.entrypoint || this.appConfig.useHttp || this.#listening) {
+    if (!this.applicationConfig.entrypoint || this.applicationConfig.useHttp || this.#listening) {
       return
     }
 
@@ -299,4 +311,17 @@ export class Controller extends EventEmitter {
 
     setGlobalDispatcher(dispatcher)
   }
+
+  #setupHandlers () {
+    process.on('uncaughtException', handleUnhandled.bind(null, this, 'uncaught exception'))
+    process.on('unhandledRejection', handleUnhandled.bind(null, this, 'unhandled rejection'))
+
+    process.on('newListener', event => {
+      if (event === 'uncaughtException' || event === 'unhandledRejection') {
+        globalThis.platformatic.logger.warn(
+          `A listener has been added for the "process.${event}" event. This listener will be never triggered as Watt default behavior will kill the process before.\n To disable this behavior, set "exitOnUnhandledErrors" to false in the runtime config.`
+        )
+      }
+    })
+  }
 }

package/lib/worker/itc.js

@@ -71,7 +71,7 @@ export async function waitEventFromITC (worker, event) {
 
 export function setupITC (controller, application, dispatcher, sharedContext) {
   const logger = globalThis.platformatic.logger
-  const messaging = new MessagingITC(controller.appConfig.id, workerData.config, logger)
+  const messaging = new MessagingITC(controller.applicationConfig.id, workerData.config, logger)
 
   Object.assign(globalThis.platformatic ?? {}, {
     messaging: {
@@ -82,7 +82,7 @@ export function setupITC (controller, application, dispatcher, sharedContext) {
   })
 
   const itc = new ITC({
-    name: controller.appConfig.id + '-worker',
+    name: controller.applicationConfig.id + '-worker',
     port: parentPort,
     handlers: {
       async start () {

package/lib/worker/main.js

@@ -2,8 +2,6 @@ import {
   buildPinoFormatters,
   buildPinoTimestamp,
   disablePinoDirectWrite,
-  ensureLoggableError,
-  executeWithTimeout,
   getPrivateSymbol
 } from '@platformatic/foundation'
 import dotenv from 'dotenv'
@@ -30,21 +28,6 @@ class ForwardingEventEmitter extends EventEmitter {
   }
 }
 
-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}"`
-
-  globalThis.platformatic.logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${type}.`)
-
-  executeWithTimeout(app?.stop(), 1000)
-    .catch()
-    .finally(() => {
-      process.exit(1)
-    })
-}
-
 function patchLogging () {
   disablePinoDirectWrite()
 
@@ -113,16 +96,16 @@ async function main () {
     events: new ForwardingEventEmitter()
   })
 
-  const config = workerData.config
+  const runtimeConfig = workerData.config
 
-  await performPreloading(config, workerData.applicationConfig)
+  await performPreloading(runtimeConfig, workerData.applicationConfig)
 
-  const application = workerData.applicationConfig
+  const applicationConfig = workerData.applicationConfig
 
   // Load env file and mixin env vars from application config
   let envfile
-  if (application.envfile) {
-    envfile = resolve(workerData.dirname, application.envfile)
+  if (applicationConfig.envfile) {
+    envfile = resolve(workerData.dirname, applicationConfig.envfile)
   } else {
     envfile = resolve(workerData.applicationConfig.path, '.env')
   }
@@ -133,20 +116,20 @@ async function main () {
     path: envfile
   })
 
-  if (config.env) {
-    Object.assign(process.env, config.env)
+  if (runtimeConfig.env) {
+    Object.assign(process.env, runtimeConfig.env)
   }
-  if (application.env) {
-    Object.assign(process.env, application.env)
+  if (applicationConfig.env) {
+    Object.assign(process.env, applicationConfig.env)
   }
 
-  const { threadDispatcher } = await setDispatcher(config)
+  const { threadDispatcher } = await setDispatcher(runtimeConfig)
 
   // If the application is an entrypoint and runtime server config is defined, use it.
   let serverConfig = null
-  if (config.server && application.entrypoint) {
-    serverConfig = config.server
-  } else if (application.useHttp) {
+  if (runtimeConfig.server && applicationConfig.entrypoint) {
+    serverConfig = runtimeConfig.server
+  } else if (applicationConfig.useHttp) {
     serverConfig = {
       port: 0,
       hostname: '127.0.0.1',
@@ -169,48 +152,32 @@ async function main () {
     const res = await fetch(url)
     const [{ devtoolsFrontendUrl }] = await res.json()
 
-    console.log(`For ${application.id} debugger open the following in chrome: "${devtoolsFrontendUrl}"`)
+    console.log(`For ${applicationConfig.id} debugger open the following in chrome: "${devtoolsFrontendUrl}"`)
   }
 
   // Create the application
   // Add idLabel to metrics config to determine which label name to use (defaults to applicationId)
-  const metricsConfig = config.metrics
+  const metricsConfig = runtimeConfig.metrics
     ? {
-        ...config.metrics,
-        idLabel: config.metrics.applicationLabel || 'applicationId'
+        ...runtimeConfig.metrics,
+        idLabel: runtimeConfig.metrics.applicationLabel || 'applicationId'
       }
-    : config.metrics
+    : runtimeConfig.metrics
 
   const controller = new Controller(
-    application,
+    runtimeConfig,
+    applicationConfig,
     workerData.worker.count > 1 ? workerData.worker.index : undefined,
-    application.telemetry,
-    config.logger,
     serverConfig,
-    metricsConfig,
-    !!config.managementApi,
-    !!config.watch
+    metricsConfig
   )
 
-  if (config.exitOnUnhandledErrors) {
-    process.on('uncaughtException', handleUnhandled.bind(null, controller, 'uncaught exception'))
-    process.on('unhandledRejection', handleUnhandled.bind(null, controller, 'unhandled rejection'))
-
-    process.on('newListener', event => {
-      if (event === 'uncaughtException' || event === 'unhandledRejection') {
-        globalThis.platformatic.logger.warn(
-          `A listener has been added for the "process.${event}" event. This listener will be never triggered as Watt default behavior will kill the process before.\n To disable this behavior, set "exitOnUnhandledErrors" to false in the runtime config.`
-        )
-      }
-    })
-  }
-
   await controller.init()
 
-  if (application.entrypoint && config.basePath) {
+  if (applicationConfig.entrypoint && runtimeConfig.basePath) {
     const meta = await controller.capability.getMeta()
     if (!meta.gateway.wantsAbsoluteUrls) {
-      stripBasePath(config.basePath)
+      stripBasePath(runtimeConfig.basePath)
     }
   }
 
@@ -222,7 +189,7 @@ async function main () {
   }
 
   // Setup interaction with parent port
-  const itc = setupITC(controller, application, threadDispatcher, sharedContext)
+  const itc = setupITC(controller, applicationConfig, threadDispatcher, sharedContext)
   globalThis[kITC] = itc
   globalThis.platformatic.itc = itc
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.7.1",
+  "version": "3.9.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -19,6 +19,7 @@
     "@fastify/express": "^4.0.0",
     "@fastify/formbody": "^8.0.0",
     "autocannon": "^8.0.0",
+    "atomic-sleep": "^1.0.0",
     "c8": "^10.0.0",
     "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
@@ -34,14 +35,14 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "3.7.1",
-    "@platformatic/db": "3.7.1",
-    "@platformatic/gateway": "3.7.1",
-    "@platformatic/node": "3.7.1",
-    "@platformatic/service": "3.7.1",
-    "@platformatic/sql-graphql": "3.7.1",
-    "@platformatic/sql-mapper": "3.7.1",
-    "@platformatic/wattpm-pprof-capture": "3.7.1"
+    "@platformatic/composer": "3.9.0",
+    "@platformatic/db": "3.9.0",
+    "@platformatic/gateway": "3.9.0",
+    "@platformatic/sql-graphql": "3.9.0",
+    "@platformatic/node": "3.9.0",
+    "@platformatic/sql-mapper": "3.9.0",
+    "@platformatic/service": "3.9.0",
+    "@platformatic/wattpm-pprof-capture": "3.9.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -71,12 +72,12 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.14.0",
     "ws": "^8.16.0",
-    "@platformatic/foundation": "3.7.1",
-    "@platformatic/basic": "3.7.1",
-    "@platformatic/itc": "3.7.1",
-    "@platformatic/generators": "3.7.1",
-    "@platformatic/metrics": "3.7.1",
-    "@platformatic/telemetry": "3.7.1"
+    "@platformatic/foundation": "3.9.0",
+    "@platformatic/generators": "3.9.0",
+    "@platformatic/itc": "3.9.0",
+    "@platformatic/basic": "3.9.0",
+    "@platformatic/metrics": "3.9.0",
+    "@platformatic/telemetry": "3.9.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.7.1.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.9.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -923,8 +923,7 @@
         {
           "type": "string"
         }
-      ],
-      "default": 1
+      ]
     },
     "workersRestartDelay": {
       "anyOf": [
@@ -1828,6 +1827,72 @@
       ],
       "additionalProperties": false
     },
+    "verticalScaler": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "default": true
+        },
+        "maxTotalWorkers": {
+          "type": "number",
+          "minimum": 1
+        },
+        "minWorkers": {
+          "type": "number",
+          "minimum": 1
+        },
+        "maxWorkers": {
+          "type": "number",
+          "minimum": 1
+        },
+        "scaleUpELU": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        },
+        "scaleDownELU": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        },
+        "minELUDiff": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        },
+        "timeWindowSec": {
+          "type": "number",
+          "minimum": 0
+        },
+        "cooldownSec": {
+          "type": "number",
+          "minimum": 0
+        },
+        "scaleIntervalSec": {
+          "type": "number",
+          "minimum": 0
+        },
+        "applications": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "minWorkers": {
+                "type": "number",
+                "minimum": 1
+              },
+              "maxWorkers": {
+                "type": "number",
+                "minimum": 1
+              }
+            },
+            "additionalProperties": false
+          }
+        }
+      },
+      "additionalProperties": false
+    },
     "inspectorOptions": {
       "type": "object",
       "properties": {