@platformatic/runtime 3.29.0 → 3.30.0

package/config.d.ts

@@ -28,6 +28,8 @@ export type PlatformaticRuntimeConfig = {
               static?: number;
               minimum?: number;
               maximum?: number;
+              scaleUpELU?: number;
+              scaleDownELU?: number;
               [k: string]: unknown;
             };
         health?: {
@@ -100,6 +102,8 @@ export type PlatformaticRuntimeConfig = {
         maxMemory?: number;
         cooldown?: number;
         gracePeriod?: number;
+        scaleUpELU?: number;
+        scaleDownELU?: number;
         [k: string]: unknown;
       };
   workersRestartDelay?: number | string;
@@ -433,13 +437,7 @@ export type PlatformaticRuntimeConfig = {
     maxWorkers?: number;
     cooldownSec?: number;
     gracePeriod?: number;
-    /**
-     * @deprecated
-     */
     scaleUpELU?: number;
-    /**
-     * @deprecated
-     */
     scaleDownELU?: number;
     /**
      * @deprecated
@@ -457,6 +455,8 @@ export type PlatformaticRuntimeConfig = {
       [k: string]: {
         minWorkers?: number;
         maxWorkers?: number;
+        scaleUpELU?: number;
+        scaleDownELU?: number;
       };
     };
   };

package/lib/config.js

@@ -298,12 +298,40 @@ export async function transform (config, _, context) {
     config.workers.maximum ??= config.verticalScaler.maxWorkers ?? config.verticalScaler.maxTotalWorkers ?? 1
     config.workers.maxMemory ??= config.verticalScaler.maxTotalMemory
 
-    if (typeof config.workers.cooldown === 'undefined' && typeof config.verticalScaler.cooldownSec === 'number') {
-      config.workers.cooldown = config.verticalScaler.cooldownSec * 1000
+    if (config.verticalScaler.cooldownSec) {
+      config.workers.cooldown ??= config.verticalScaler.cooldownSec * 1000
     }
+    if (config.verticalScaler.gracePeriod) {
+      config.workers.gracePeriod ??= config.verticalScaler.gracePeriod
+    }
+    if (config.verticalScaler.scaleUpELU) {
+      config.workers.scaleUpELU ??= config.verticalScaler.scaleUpELU
+    }
+    if (config.verticalScaler.scaleDownELU) {
+      config.workers.scaleDownELU ??= config.verticalScaler.scaleDownELU
+    }
+
+    if (config.verticalScaler.applications) {
+      for (const appId in config.verticalScaler.applications) {
+        let appConfig = applications.find((app) => app.id === appId)
+        if (!appConfig) {
+          appConfig = { id: appId, workers: {} }
+          applications.push(appConfig)
+        }
 
-    if (typeof config.workers.gracePeriod === 'undefined' && typeof config.verticalScaler.gracePeriod === 'number') {
-      config.workers.gracePeriod = config.verticalScaler.gracePeriod
+        const scaleConfig = config.verticalScaler.applications[appId]
+        const workersConfig = appConfig.workers
+
+        workersConfig.minimum ??= scaleConfig.minWorkers ?? config.workers.minimum
+        workersConfig.maximum ??= scaleConfig.maxWorkers ?? config.workers.maximum
+
+        if (scaleConfig.scaleUpELU) {
+          workersConfig.scaleUpELU ??= scaleConfig.scaleUpELU
+        }
+        if (scaleConfig.scaleDownELU) {
+          workersConfig.scaleDownELU ??= scaleConfig.scaleDownELU
+        }
+      }
     }
 
     config.verticalScaler = undefined

package/lib/runtime.js

@@ -710,6 +710,56 @@ export class Runtime extends EventEmitter {
     }
   }
 
+  /**
+   * Updates the metrics configuration at runtime without restarting the runtime or workers.
+   *
+   * This method allows you to:
+   * - Enable or disable metrics collection
+   * - Change Prometheus server settings (port, endpoint, authentication)
+   * - Update custom labels for metrics
+   *
+   * @example
+   * // Enable metrics with custom port
+   * await runtime.updateMetricsConfig({
+   *   enabled: true,
+   *   port: 9091,
+   *   labels: { environment: 'production' }
+   * })
+   *
+   * // Disable metrics
+   * await runtime.updateMetricsConfig({ enabled: false })
+   */
+  async updateMetricsConfig (metricsConfig) {
+    if (this.#prometheusServer) {
+      await this.#prometheusServer.close()
+      this.#prometheusServer = null
+    }
+
+    this.#config.metrics = metricsConfig
+    this.#metricsLabelName = metricsConfig?.applicationLabel || 'applicationId'
+
+    if (metricsConfig.enabled !== false) {
+      this.#prometheusServer = await startPrometheusServer(this, metricsConfig)
+    }
+
+    const promises = []
+    for (const worker of this.#workers.values()) {
+      if (worker[kWorkerStatus] === 'started') {
+        promises.push(sendViaITC(worker, 'updateMetricsConfig', metricsConfig))
+      }
+    }
+
+    const results = await Promise.allSettled(promises)
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        this.logger.error({ err: result.reason }, 'Cannot update metrics config on worker')
+      }
+    }
+
+    this.logger.info({ metricsConfig }, 'Metrics configuration updated')
+    return { success: true, config: metricsConfig }
+  }
+
   // TODO: Remove in next major version
   startCollectingMetrics () {
     this.logger.warn(

package/lib/scaling-algorithm.js

@@ -1,5 +1,3 @@
-export const scaleUpELUThreshold = 0.8
-export const scaleDownELUThreshold = 0.2
 export const scaleUpTimeWindow = 10_000
 export const scaleDownTimeWindow = 60_000
 
@@ -7,15 +5,23 @@ 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) {
+  addApplication (id, config = {}) {
+    config.scaleUpELU ??= this.#scaleUpELU
+    config.scaleDownELU ??= this.#scaleDownELU
+
     this.#appsConfigs[id] = config
+    this.#appsMetrics[id] ??= {}
   }
 
   removeApplication (id) {
@@ -28,8 +34,9 @@ export class ScalingAlgorithm {
     const timestamp = Date.now()
 
     if (!this.#appsMetrics[applicationId]) {
-      this.#appsMetrics[applicationId] = {}
+      throw new Error(`Missing application "${applicationId}" in the scaling algorithm.`)
     }
+
     if (!this.#appsMetrics[applicationId][workerId]) {
       this.#appsMetrics[applicationId][workerId] = []
     }
@@ -234,12 +241,13 @@ export class ScalingAlgorithm {
     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 > scaleUpELUThreshold) {
+    if (scaleUpELU > config.scaleUpELU) {
       recommendation = 'scaleUp'
     }
-    if (scaleDownELU < scaleDownELUThreshold) {
+    if (scaleDownELU < config.scaleDownELU) {
       recommendation = 'scaleDown'
     }
 

package/lib/schema.js

@@ -22,7 +22,9 @@ schemaComponents.runtimeProperties.verticalScaler.properties.applications = {
     type: 'object',
     properties: {
       minWorkers: { type: 'number', minimum: 1 },
-      maxWorkers: { type: 'number', minimum: 1 }
+      maxWorkers: { type: 'number', minimum: 1 },
+      scaleUpELU: { type: 'number', minimum: 0, maximum: 1 },
+      scaleDownELU: { type: 'number', minimum: 0, maximum: 1 }
     },
     additionalProperties: false
   }

package/lib/worker/controller.js

@@ -92,6 +92,13 @@ export class Controller extends EventEmitter {
     }
   }
 
+  async updateMetricsConfig (metricsConfig) {
+    this.#context.metricsConfig = metricsConfig
+    if (this.capability && typeof this.capability.updateMetricsConfig === 'function') {
+      await this.capability.updateMetricsConfig(metricsConfig)
+    }
+  }
+
   // Note: capability's init() is executed within start
   async init () {
     try {

package/lib/worker/itc.js

@@ -2,8 +2,8 @@ import { ensureLoggableError, executeInParallel, executeWithTimeout, kTimeout }
 import { ITC } from '@platformatic/itc'
 import { Unpromise } from '@watchable/unpromise'
 import { once } from 'node:events'
-import repl from 'node:repl'
 import { Duplex } from 'node:stream'
+import { createRequire } from 'node:module'
 import { parentPort, workerData } from 'node:worker_threads'
 import {
   ApplicationExitedError,
@@ -176,6 +176,13 @@ export function setupITC (controller, application, dispatcher, sharedContext) {
         await updateUndiciInterceptors(undiciConfig)
       },
 
+      async updateMetricsConfig (metricsConfig) {
+        if (controller && typeof controller.updateMetricsConfig === 'function') {
+          await controller.updateMetricsConfig(metricsConfig)
+        }
+        return { success: true }
+      },
+
       async updateWorkersCount (data) {
         const { workers } = data
         workerData.applicationConfig.workers = workers
@@ -266,6 +273,14 @@ export function setupITC (controller, application, dispatcher, sharedContext) {
       },
 
       startRepl (port) {
+        // We are loading the repl module dynamically here to avoid loading it
+        // when not needed (since it pulls in domain, which is quite expensive
+        // as it monkey patches EventEmitter).
+        // We must use local require() instead of import
+        // because dynamic import() is async and the
+        // startRepl handler is sync.
+        const repl = createRequire(import.meta.url)('node:repl')
+
         // Create a duplex stream that wraps the MessagePort
         const replStream = new Duplex({
           read () {},

package/lib/worker-scaler.js

@@ -1,7 +1,7 @@
 import { features } from '@platformatic/foundation'
 import { availableParallelism } from 'node:os'
 import { getMemoryInfo } from './metrics.js'
-import { ScalingAlgorithm, scaleUpELUThreshold } from './scaling-algorithm.js'
+import { ScalingAlgorithm } from './scaling-algorithm.js'
 import { kApplicationId, kId, kLastWorkerScalerELU, kWorkerStartTime, kWorkerStatus } from './worker/symbols.js'
 
 const healthCheckInterval = 1000
@@ -20,6 +20,8 @@ export class DynamicWorkersScaler {
   #maxTotalWorkers
   #maxWorkers
   #minWorkers
+  #scaleUpELU
+  #scaleDownELU
   #cooldown
   #gracePeriod
 
@@ -29,6 +31,7 @@ export class DynamicWorkersScaler {
   #checkScalingInterval
   #isScaling
   #lastScaling
+  #appsConfigs
 
   constructor (runtime, config) {
     this.#runtime = runtime
@@ -37,15 +40,22 @@ export class DynamicWorkersScaler {
     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 })
+    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 () {
@@ -100,10 +110,14 @@ export class DynamicWorkersScaler {
     } 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 }
@@ -115,6 +129,7 @@ export class DynamicWorkersScaler {
       }
     }
 
+    this.#appsConfigs[application.id] = config
     this.#algorithm.addApplication(application.id, config)
   }
 
@@ -143,15 +158,20 @@ export class DynamicWorkersScaler {
 
         worker[kLastWorkerScalerELU] = health.currentELU
 
+        const workerId = worker[kId]
+        const applicationId = worker[kApplicationId]
+        const scaleConfig = this.#appsConfigs[applicationId]
+        if (!scaleConfig) continue
+
         this.#algorithm.addWorkerHealthInfo({
-          workerId: worker[kId],
-          applicationId: worker[kApplicationId],
+          workerId,
+          applicationId,
           elu: health.elu,
           heapUsed: health.heapUsed,
           heapTotal: health.heapTotal
         })
 
-        if (health.elu > scaleUpELUThreshold) {
+        if (health.elu > scaleConfig.scaleUpELU) {
           shouldCheckForScaling = true
         }
       } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.29.0",
+  "version": "3.30.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/composer": "3.29.0",
-    "@platformatic/db": "3.29.0",
-    "@platformatic/node": "3.29.0",
-    "@platformatic/service": "3.29.0",
-    "@platformatic/sql-mapper": "3.29.0",
-    "@platformatic/sql-graphql": "3.29.0",
-    "@platformatic/wattpm-pprof-capture": "3.29.0",
-    "@platformatic/gateway": "3.29.0"
+    "@platformatic/composer": "3.30.0",
+    "@platformatic/db": "3.30.0",
+    "@platformatic/gateway": "3.30.0",
+    "@platformatic/node": "3.30.0",
+    "@platformatic/sql-graphql": "3.30.0",
+    "@platformatic/sql-mapper": "3.30.0",
+    "@platformatic/service": "3.30.0",
+    "@platformatic/wattpm-pprof-capture": "3.30.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -58,7 +58,7 @@
     "cron": "^4.1.0",
     "debounce": "^2.0.0",
     "fastest-levenshtein": "^1.0.16",
-    "fastify": "^5.0.0",
+    "fastify": "^5.7.0",
     "graphql": "^16.8.1",
     "help-me": "^5.0.0",
     "minimist": "^1.2.8",
@@ -71,12 +71,12 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^1.0.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.29.0",
-    "@platformatic/foundation": "3.29.0",
-    "@platformatic/generators": "3.29.0",
-    "@platformatic/itc": "3.29.0",
-    "@platformatic/telemetry": "3.29.0",
-    "@platformatic/metrics": "3.29.0"
+    "@platformatic/foundation": "3.30.0",
+    "@platformatic/basic": "3.30.0",
+    "@platformatic/generators": "3.30.0",
+    "@platformatic/itc": "3.30.0",
+    "@platformatic/telemetry": "3.30.0",
+    "@platformatic/metrics": "3.30.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.29.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.30.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -90,6 +90,16 @@
                       "maximum": {
                         "type": "number",
                         "minimum": 0
+                      },
+                      "scaleUpELU": {
+                        "type": "number",
+                        "minimum": 0,
+                        "maximum": 1
+                      },
+                      "scaleDownELU": {
+                        "type": "number",
+                        "minimum": 0,
+                        "maximum": 1
                       }
                     }
                   }
@@ -394,6 +404,16 @@
                   "maximum": {
                     "type": "number",
                     "minimum": 0
+                  },
+                  "scaleUpELU": {
+                    "type": "number",
+                    "minimum": 0,
+                    "maximum": 1
+                  },
+                  "scaleDownELU": {
+                    "type": "number",
+                    "minimum": 0,
+                    "maximum": 1
                   }
                 }
               }
@@ -696,6 +716,16 @@
                   "maximum": {
                     "type": "number",
                     "minimum": 0
+                  },
+                  "scaleUpELU": {
+                    "type": "number",
+                    "minimum": 0,
+                    "maximum": 1
+                  },
+                  "scaleDownELU": {
+                    "type": "number",
+                    "minimum": 0,
+                    "maximum": 1
                   }
                 }
               }
@@ -998,6 +1028,16 @@
                   "maximum": {
                     "type": "number",
                     "minimum": 0
+                  },
+                  "scaleUpELU": {
+                    "type": "number",
+                    "minimum": 0,
+                    "maximum": 1
+                  },
+                  "scaleDownELU": {
+                    "type": "number",
+                    "minimum": 0,
+                    "maximum": 1
                   }
                 }
               }
@@ -1277,6 +1317,16 @@
             "gracePeriod": {
               "type": "number",
               "minimum": 0
+            },
+            "scaleUpELU": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
+            },
+            "scaleDownELU": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1
             }
           }
         }
@@ -2313,14 +2363,12 @@
         "scaleUpELU": {
           "type": "number",
           "minimum": 0,
-          "maximum": 1,
-          "deprecated": true
+          "maximum": 1
         },
         "scaleDownELU": {
           "type": "number",
           "minimum": 0,
-          "maximum": 1,
-          "deprecated": true
+          "maximum": 1
         },
         "timeWindowSec": {
           "type": "number",
@@ -2349,6 +2397,16 @@
               "maxWorkers": {
                 "type": "number",
                 "minimum": 1
+              },
+              "scaleUpELU": {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 1
+              },
+              "scaleDownELU": {
+                "type": "number",
+                "minimum": 0,
+                "maximum": 1
               }
             },
             "additionalProperties": false