@platformatic/runtime 3.10.0 → 3.12.0

package/config.d.ts

@@ -365,12 +365,13 @@ export type PlatformaticRuntimeConfig = {
   verticalScaler?: {
     enabled?: boolean;
     maxTotalWorkers?: number;
+    maxTotalMemory?: number;
     minWorkers?: number;
     maxWorkers?: number;
     scaleUpELU?: number;
     scaleDownELU?: number;
-    minELUDiff?: number;
     timeWindowSec?: number;
+    scaleDownTimeWindowSec?: number;
     cooldownSec?: number;
     scaleIntervalSec?: number;
     gracePeriod?: number;
@@ -412,4 +413,13 @@ export type PlatformaticRuntimeConfig = {
     maxRetries?: number;
     [k: string]: unknown;
   }[];
+  policies?: {
+    deny: {
+      /**
+       * This interface was referenced by `undefined`'s JSON-Schema definition
+       * via the `patternProperty` "^.*$".
+       */
+      [k: string]: string | [string, ...string[]];
+    };
+  };
 };

package/index.js

@@ -44,7 +44,7 @@ function handleSignal (runtime, config) {
 
   const cwg = closeWithGrace({ delay: config.gracefulShutdown?.runtime ?? 10000, onTimeout }, async event => {
     if (event.err instanceof Error) {
-      console.error(event.err)
+      console.error(new Error('@platformatic/runtime threw an unexpected error', { cause: event.err }))
     }
     await runtime.close()
   })

package/lib/config.js

@@ -335,13 +335,21 @@ export async function transform (config, _, context) {
     // like adding other applications.
   }
 
-  if (config.metrics === true) {
+  if (typeof config.metrics === 'boolean') {
     config.metrics = {
-      enabled: true,
+      enabled: config.metrics,
       timeout: 1000
     }
   }
 
+  if (config.policies?.deny) {
+    for (const [from, to] of Object.entries(config.policies.deny)) {
+      if (typeof to === 'string') {
+        config.policies.deny[from] = [to]
+      }
+    }
+  }
+
   config.applications = applications
   config.web = undefined
   config.services = undefined

package/lib/management-api.js

@@ -132,6 +132,17 @@ export async function managementApiPlugin (app, opts) {
   })
 
   app.get('/metrics', { logLevel: 'debug' }, async (req, reply) => {
+    const config = await runtime.getRuntimeConfig()
+
+    if (config.metrics?.enabled === false) {
+      reply.code(501)
+      return {
+        statusCode: 501,
+        error: 'Not Implemented',
+        message: 'Metrics are disabled.'
+      }
+    }
+
     const accepts = req.accepts()
 
     if (!accepts.type('text/plain') && accepts.type('application/json')) {
@@ -145,6 +156,23 @@ export async function managementApiPlugin (app, opts) {
   })
 
   app.get('/metrics/live', { websocket: true }, async socket => {
+    const config = await runtime.getRuntimeConfig()
+
+    if (config.metrics?.enabled === false) {
+      socket.send(
+        JSON.stringify({
+          statusCode: 501,
+          error: 'Not Implemented',
+          message: 'Metrics are disabled.'
+        }),
+        () => {
+          socket.close()
+        }
+      )
+
+      return
+    }
+
     const cachedMetrics = runtime.getCachedMetrics()
     if (cachedMetrics.length > 0) {
       const serializedMetrics = cachedMetrics.map(metric => JSON.stringify(metric)).join('\n')

package/lib/metrics.js

@@ -0,0 +1,73 @@
+import { readFile } from 'node:fs/promises'
+import si from 'systeminformation'
+
+async function readNumberFromCgroupFile (path) {
+  try {
+    const raw = (await readFile(path, 'utf8')).trim()
+    if (raw === 'max') return null
+    return Number(raw)
+  } catch {
+    return null
+  }
+}
+
+async function getCgroupV2MemoryInfo () {
+  let [total, used] = await Promise.all([
+    readNumberFromCgroupFile('/sys/fs/cgroup/memory.max'),
+    readNumberFromCgroupFile('/sys/fs/cgroup/memory.current')
+  ])
+  if (total == null && used == null) return null
+
+  if (total === null) {
+    const mem = await si.mem()
+    total = mem.total
+  }
+
+  return { scope: 'cgroup-v2', used, total }
+}
+
+async function getCgroupV1MemoryInfo () {
+  let [total, used] = await Promise.all([
+    readNumberFromCgroupFile('/sys/fs/cgroup/memory/memory.limit_in_bytes'),
+    readNumberFromCgroupFile('/sys/fs/cgroup/memory/memory.usage_in_bytes')
+  ])
+  if (total == null && used == null) return null
+
+  // Some v1 setups report 9.22e18 (≈unlimited)
+  if (total === null || total > 1e18) {
+    const mem = await si.mem()
+    total = mem.total
+  }
+
+  return { scope: 'cgroup-v1', used, total }
+}
+
+async function readHostMemoryInfo () {
+  const mem = await si.mem()
+  return { scope: 'host', used: mem.active, total: mem.total }
+}
+
+export async function getMemoryInfo (options = {}) {
+  const scope = options.scope
+
+  if (scope === 'cgroup-v2') {
+    return getCgroupV2MemoryInfo()
+  }
+  if (scope === 'cgroup-v1') {
+    return getCgroupV1MemoryInfo()
+  }
+  if (scope === 'host') {
+    return readHostMemoryInfo()
+  }
+
+  let memInfo = await getCgroupV2MemoryInfo()
+
+  if (!memInfo) {
+    memInfo = await getCgroupV1MemoryInfo()
+  }
+  if (!memInfo) {
+    memInfo = await readHostMemoryInfo()
+  }
+
+  return memInfo
+}

package/lib/policies.js

@@ -0,0 +1,23 @@
+export function createChannelCreationHook (config) {
+  const denyList = config.policies?.deny
+
+  if (typeof denyList === 'undefined') {
+    return undefined
+  }
+
+  const forbidden = new Set()
+
+  for (let [first, unalloweds] of Object.entries(denyList)) {
+    for (let second of unalloweds) {
+      first = first.toLowerCase()
+      second = second.toLowerCase()
+
+      forbidden.add(`${first}:${second}`)
+      forbidden.add(`${second}:${first}`)
+    }
+  }
+
+  return function channelCreationHook (first, second) {
+    return !forbidden.has(`${first.toLowerCase()}:${second.toLowerCase()}`)
+  }
+}

package/lib/runtime.js

@@ -40,6 +40,8 @@ import {
 } from './errors.js'
 import { abstractLogger, createLogger } from './logger.js'
 import { startManagementApi } from './management-api.js'
+import { getMemoryInfo } from './metrics.js'
+import { createChannelCreationHook } from './policies.js'
 import { startPrometheusServer } from './prom-server.js'
 import ScalingAlgorithm from './scaling-algorithm.js'
 import { startScheduler } from './scheduler.js'
@@ -58,8 +60,8 @@ import {
   kStderrMarker,
   kWorkerId,
   kWorkersBroadcast,
-  kWorkerStatus,
-  kWorkerStartTime
+  kWorkerStartTime,
+  kWorkerStatus
 } from './worker/symbols.js'
 
 const kWorkerFile = join(import.meta.dirname, 'worker/main.js')
@@ -112,6 +114,8 @@ export class Runtime extends EventEmitter {
   #sharedHttpCache
   #scheduler
 
+  #channelCreationHook
+
   constructor (config, context) {
     super()
     this.setMaxListeners(MAX_LISTENERS_COUNT)
@@ -124,7 +128,12 @@ export class Runtime extends EventEmitter {
     this.#concurrency = this.#context.concurrency ?? MAX_CONCURRENCY
     this.#workers = new RoundRobinMap()
     this.#url = undefined
-    this.#meshInterceptor = createThreadInterceptor({ domain: '.plt.local', timeout: this.#config.applicationTimeout })
+    this.#channelCreationHook = createChannelCreationHook(this.#config)
+    this.#meshInterceptor = createThreadInterceptor({
+      domain: '.plt.local',
+      timeout: this.#config.applicationTimeout,
+      onChannelCreation: this.#channelCreationHook
+    })
     this.logger = abstractLogger // This is replaced by the real logger in init() and eventually removed in close()
     this.#status = undefined
     this.#restartingWorkers = new Map()
@@ -274,7 +283,7 @@ export class Runtime extends EventEmitter {
 
     this.#updateStatus('started')
 
-    if (this.#managementApi && typeof this.#metrics === 'undefined') {
+    if (this.#config.metrics?.enabled !== false && typeof this.#metrics === 'undefined') {
       this.startCollectingMetrics()
     }
 
@@ -1605,7 +1614,7 @@ export class Runtime extends EventEmitter {
       } else {
         worker[kHealthCheckTimer].refresh()
       }
-    }, interval)
+    }, interval).unref()
   }
 
   async #startWorker (
@@ -2002,7 +2011,14 @@ export class Runtime extends EventEmitter {
     }
   }
 
-  async #getWorkerMessagingChannel ({ application, worker }, context) {
+  async #getWorkerMessagingChannel ({ id, application, worker }, context) {
+    if (this.#channelCreationHook?.(id, application) === false) {
+      throw new MessagingError(
+        application,
+        `Communication channels are disabled between applications "${id}" and "${application}".`
+      )
+    }
+
     const target = await this.#getWorkerById(application, worker, true, true)
 
     const { port1, port2 } = new MessageChannel()
@@ -2084,8 +2100,15 @@ export class Runtime extends EventEmitter {
         }
       }
 
-      const pinoLog =
-        typeof message?.level === 'number' && typeof message?.time === 'number' && typeof message?.msg === 'string'
+      let pinoLog
+
+      if (typeof message === 'object') {
+        pinoLog =
+          typeof message.level === 'number' &&
+          // We want to accept both pino raw time (number) and time as formatted string
+          (typeof message.time === 'number' || typeof message.time === 'string') &&
+          typeof message.msg === 'string'
+      }
 
       // Directly write to the Pino destination
       if (pinoLog) {
@@ -2466,35 +2489,37 @@ export class Runtime extends EventEmitter {
   async #setupVerticalScaler () {
     const fixedWorkersCount = this.#config.workers
     if (fixedWorkersCount !== undefined) {
-      this.logger.warn(
-        `Vertical scaler disabled because the "workers" configuration is set to ${fixedWorkersCount}`
-      )
+      this.logger.warn(`Vertical scaler disabled because the "workers" configuration is set to ${fixedWorkersCount}`)
       return
     }
 
     const scalerConfig = this.#config.verticalScaler
+    const memInfo = await getMemoryInfo()
+    const memScope = memInfo.scope
 
     scalerConfig.maxTotalWorkers ??= os.availableParallelism()
+    scalerConfig.maxTotalMemory ??= memInfo.total * 0.9
     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.timeWindowSec ??= 10
+    scalerConfig.scaleDownTimeWindowSec ??= 60
     scalerConfig.gracePeriod ??= 30 * 1000
     scalerConfig.applications ??= {}
 
     const maxTotalWorkers = scalerConfig.maxTotalWorkers
+    const maxTotalMemory = scalerConfig.maxTotalMemory
     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 scaleDownTimeWindowSec = scalerConfig.scaleDownTimeWindowSec
     const applicationsConfigs = scalerConfig.applications
     const gracePeriod = scalerConfig.gracePeriod
     const healthCheckInterval = 1000
@@ -2505,7 +2530,7 @@ export class Runtime extends EventEmitter {
       if (application.entrypoint && !features.node.reusePort) {
         this.logger.warn(
           `The "${application.id}" application cannot be scaled because it is an entrypoint` +
-          ' and the "reusePort" feature is not available in your OS.'
+            ' and the "reusePort" feature is not available in your OS.'
         )
 
         applicationsConfigs[application.id] = {
@@ -2517,7 +2542,7 @@ export class Runtime extends EventEmitter {
       if (application.workers !== undefined) {
         this.logger.warn(
           `The "${application.id}" application cannot be scaled because` +
-          ` it has a fixed number of workers (${application.workers}).`
+            ` it has a fixed number of workers (${application.workers}).`
         )
         applicationsConfigs[application.id] = {
           minWorkers: application.workers,
@@ -2558,8 +2583,8 @@ export class Runtime extends EventEmitter {
       maxTotalWorkers,
       scaleUpELU,
       scaleDownELU,
-      minELUDiff,
-      timeWindowSec,
+      scaleUpTimeWindowSec: timeWindowSec,
+      scaleDownTimeWindowSec,
       applications: applicationsConfigs
     })
 
@@ -2569,10 +2594,7 @@ export class Runtime extends EventEmitter {
       const now = Date.now()
 
       for (const worker of this.#workers.values()) {
-        if (
-          worker[kWorkerStatus] !== 'started' ||
-          worker[kWorkerStartTime] + gracePeriod > now
-        ) {
+        if (worker[kWorkerStatus] !== 'started' || worker[kWorkerStartTime] + gracePeriod > now) {
           continue
         }
 
@@ -2583,7 +2605,9 @@ export class Runtime extends EventEmitter {
           scalingAlgorithm.addWorkerHealthInfo({
             workerId: worker[kId],
             applicationId: worker[kApplicationId],
-            elu: health.elu
+            elu: health.elu,
+            heapUsed: health.heapUsed,
+            heapTotal: health.heapTotal
           })
 
           if (health.elu > scaleUpELU) {
@@ -2611,6 +2635,7 @@ export class Runtime extends EventEmitter {
 
       try {
         const workersInfo = await this.getWorkers()
+        const mem = await getMemoryInfo({ scope: memScope })
 
         const appsWorkersInfo = {}
         for (const worker of Object.values(workersInfo)) {
@@ -2621,7 +2646,10 @@ export class Runtime extends EventEmitter {
           appsWorkersInfo[applicationId]++
         }
 
-        const recommendations = scalingAlgorithm.getRecommendations(appsWorkersInfo)
+        const availableMemory = maxTotalMemory - mem.used
+        const recommendations = scalingAlgorithm.getRecommendations(appsWorkersInfo, {
+          availableMemory
+        })
         if (recommendations.length > 0) {
           await applyRecommendations(recommendations)
           lastScaling = Date.now()

package/lib/scaling-algorithm.js

@@ -2,60 +2,63 @@ class ScalingAlgorithm {
   #scaleUpELU
   #scaleDownELU
   #maxTotalWorkers
-  #timeWindowSec
-  #appsELUs
-  #minELUDiff
+  #scaleUpTimeWindowSec
+  #scaleDownTimeWindowSec
+  #appsMetrics
   #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.#maxTotalWorkers = options.maxTotalWorkers ?? Infinity
+    this.#scaleUpTimeWindowSec = options.scaleUpTimeWindowSec ?? 10
+    this.#scaleDownTimeWindowSec = options.scaleDownTimeWindowSec ?? 60
     this.#appsConfigs = options.applications ?? {}
 
-    this.#appsELUs = {}
+    this.#appsMetrics = {}
   }
 
   addWorkerHealthInfo (healthInfo) {
-    const { workerId, applicationId, elu } = healthInfo
+    const { workerId, applicationId, elu, heapUsed } = healthInfo
     const timestamp = Date.now()
 
-    if (!this.#appsELUs[applicationId]) {
-      this.#appsELUs[applicationId] = {}
+    if (!this.#appsMetrics[applicationId]) {
+      this.#appsMetrics[applicationId] = {}
     }
-    if (!this.#appsELUs[applicationId][workerId]) {
-      this.#appsELUs[applicationId][workerId] = []
+    if (!this.#appsMetrics[applicationId][workerId]) {
+      this.#appsMetrics[applicationId][workerId] = []
     }
-    this.#appsELUs[applicationId][workerId].push({ elu, timestamp })
+    this.#appsMetrics[applicationId][workerId].push({
+      elu,
+      timestamp,
+      heapUsed
+    })
     this.#removeOutdatedAppELUs(applicationId)
   }
 
-  getRecommendations (appsWorkersInfo) {
+  getRecommendations (appsWorkersInfo, options = {}) {
     let totalWorkersCount = 0
-    let appsInfo = []
+    let totalAvailableMemory = options.availableMemory ?? Infinity
+
+    const appsInfo = []
 
     for (const applicationId in appsWorkersInfo) {
       const workersCount = appsWorkersInfo[applicationId]
-      const elu = this.#calculateAppAvgELU(applicationId)
-      appsInfo.push({ applicationId, workersCount, elu })
+
+      const { heapUsed } = this.#calculateAppAvgMetrics(applicationId)
+
+      appsInfo.push({
+        applicationId,
+        workersCount,
+        avgHeapUsed: heapUsed,
+      })
+
       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) {
+    for (const { applicationId, workersCount, avgHeapUsed } of appsInfo) {
       const appMinWorkers = this.#appsConfigs[applicationId]?.minWorkers ?? 1
       const appMaxWorkers = this.#appsConfigs[applicationId]?.maxWorkers ?? this.#maxTotalWorkers
 
@@ -65,7 +68,10 @@ class ScalingAlgorithm {
           workersCount: appMinWorkers,
           direction: 'up'
         })
-        totalWorkersCount += appMinWorkers - workersCount
+
+        const newWorkersCount = appMinWorkers - workersCount
+        totalWorkersCount += newWorkersCount
+        totalAvailableMemory += newWorkersCount * avgHeapUsed
         continue
       }
 
@@ -75,103 +81,122 @@ class ScalingAlgorithm {
           workersCount: appMaxWorkers,
           direction: 'down'
         })
-        totalWorkersCount -= workersCount - appMaxWorkers
+
+        const removedWorkersCount = workersCount - appMaxWorkers
+        totalWorkersCount -= removedWorkersCount
+        totalAvailableMemory -= removedWorkersCount * avgHeapUsed
         continue
       }
 
-      if (elu < this.#scaleDownELU && workersCount > appMinWorkers) {
-        recommendations.push({
-          applicationId,
-          workersCount: workersCount - 1,
-          direction: 'down'
-        })
-        totalWorkersCount--
+      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
+        }
       }
     }
 
-    for (const scaleUpCandidate of appsInfo.toReversed()) {
-      if (scaleUpCandidate.elu < this.#scaleUpELU) break
-
-      const { applicationId, workersCount } = scaleUpCandidate
-
-      const isScaled = recommendations.some(
-        r => r.applicationId === applicationId &&
-          r.direction === 'up'
-      )
-      if (isScaled) continue
-
-      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 (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 (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 {
+      if (scaleUpCandidate) {
         recommendations.push({
-          applicationId,
-          workersCount: workersCount + 1,
+          applicationId: scaleUpCandidate.applicationId,
+          workersCount: scaleUpCandidate.workersCount + 1,
           direction: 'up'
         })
         totalWorkersCount++
+        totalAvailableMemory -= scaleUpCandidate.heapUsed
       }
-      break
     }
 
     return recommendations
   }
 
-  #calculateAppAvgELU (applicationId) {
+  #calculateAppAvgMetrics (applicationId, options = {}) {
     this.#removeOutdatedAppELUs(applicationId)
 
-    const appELUs = this.#appsELUs[applicationId]
-    if (!appELUs) return 0
+    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 eluCount = 0
+    let heapUsedSum = 0
+    let count = 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++
-    }
+    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 (eluCount === 0) return 0
+      if (metricCount === 0) continue
 
-    return Math.round(eluSum / eluCount * 100) / 100
+      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.#appsELUs[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]
@@ -179,7 +204,7 @@ class ScalingAlgorithm {
       let firstValidIndex = -1
       for (let i = 0; i < workerELUs.length; i++) {
         const timestamp = workerELUs[i].timestamp
-        if (timestamp >= now - this.#timeWindowSec * 1000) {
+        if (timestamp >= now - timeWindow) {
           firstValidIndex = i
           break
         }
@@ -199,6 +224,30 @@ class ScalingAlgorithm {
       }
     }
   }
+
+  #getMetricsTimeWindow () {
+    return Math.max(this.#scaleUpTimeWindowSec, this.#scaleDownTimeWindowSec) * 1000
+  }
+
+  #getApplicationScaleRecommendation (applicationId) {
+    const { elu: scaleUpELU } = this.#calculateAppAvgMetrics(applicationId, {
+      timeWindow: this.#scaleUpTimeWindowSec * 1000
+    })
+    const { elu: scaleDownELU } = this.#calculateAppAvgMetrics(applicationId, {
+      timeWindow: this.#scaleDownTimeWindowSec * 1000
+    })
+    const { heapUsed: avgHeapUsage } = this.#calculateAppAvgMetrics(applicationId)
+
+    let recommendation = null
+    if (scaleUpELU > this.#scaleUpELU) {
+      recommendation = 'scaleUp'
+    }
+    if (scaleDownELU < this.#scaleDownELU) {
+      recommendation = 'scaleDown'
+    }
+
+    return { recommendation, scaleUpELU, scaleDownELU, avgHeapUsage }
+  }
 }
 
 export default ScalingAlgorithm

package/lib/worker/interceptors.js

@@ -5,6 +5,7 @@ import { pathToFileURL } from 'node:url'
 import { parentPort, workerData } from 'node:worker_threads'
 import { Agent, Client, Pool, setGlobalDispatcher } from 'undici'
 import { wire } from 'undici-thread-interceptor'
+import { createChannelCreationHook } from '../policies.js'
 import { RemoteCacheStore, httpCacheInterceptor } from './http-cache.js'
 import { kInterceptors } from './symbols.js'
 
@@ -171,6 +172,7 @@ function createThreadInterceptor (runtimeConfig) {
     domain: '.plt.local',
     port: parentPort,
     timeout: runtimeConfig.applicationTimeout,
+    onChannelCreation: createChannelCreationHook(runtimeConfig),
     ...telemetryHooks
   })
   return threadDispatcher

package/lib/worker/messaging.js

@@ -1,5 +1,5 @@
-import { executeWithTimeout, ensureLoggableError, kTimeout } from '@platformatic/foundation'
-import { ITC, parseRequest, generateRequest, generateResponse, sanitize, errors } from '@platformatic/itc'
+import { ensureLoggableError, executeWithTimeout, kTimeout } from '@platformatic/foundation'
+import { errors, generateRequest, generateResponse, ITC, parseRequest, sanitize } from '@platformatic/itc'
 import { MessagingError } from '../errors.js'
 import { RoundRobinMap } from './round-robin-map.js'
 import { kITC, kWorkersBroadcast } from './symbols.js'
@@ -7,6 +7,7 @@ import { kITC, kWorkersBroadcast } from './symbols.js'
 const kPendingResponses = Symbol('plt.messaging.pendingResponses')
 
 export class MessagingITC extends ITC {
+  #id
   #timeout
   #listener
   #closeResolvers
@@ -22,6 +23,7 @@ export class MessagingITC extends ITC {
       name: `${id}-messaging`
     })
 
+    this.#id = id
     this.#timeout = runtimeConfig.messagingTimeout
     this.#workers = new RoundRobinMap()
     this.#sources = new Set()
@@ -67,7 +69,11 @@ export class MessagingITC extends ITC {
       // Use twice the value here as a fallback measure. The target handler in the main thread is forwarding
       // the request to the worker, using executeWithTimeout with the user set timeout value.
       const channel = await executeWithTimeout(
-        globalThis[kITC].send('getWorkerMessagingChannel', { application: worker.application, worker: worker.worker }),
+        globalThis[kITC].send('getWorkerMessagingChannel', {
+          id: this.#id,
+          application: worker.application,
+          worker: worker.worker
+        }),
         this.#timeout * 2
       )
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.10.0",
+  "version": "3.12.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -18,8 +18,8 @@
     "@fastify/compress": "^8.0.0",
     "@fastify/express": "^4.0.0",
     "@fastify/formbody": "^8.0.0",
-    "autocannon": "^8.0.0",
     "atomic-sleep": "^1.0.0",
+    "autocannon": "^8.0.0",
     "c8": "^10.0.0",
     "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
@@ -35,14 +35,14 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "3.10.0",
-    "@platformatic/db": "3.10.0",
-    "@platformatic/node": "3.10.0",
-    "@platformatic/gateway": "3.10.0",
-    "@platformatic/service": "3.10.0",
-    "@platformatic/sql-graphql": "3.10.0",
-    "@platformatic/sql-mapper": "3.10.0",
-    "@platformatic/wattpm-pprof-capture": "3.10.0"
+    "@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"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -69,15 +69,16 @@
     "prom-client": "^15.1.2",
     "semgrator": "^0.3.0",
     "sonic-boom": "^4.2.0",
+    "systeminformation": "^5.27.11",
     "undici": "^7.0.0",
-    "undici-thread-interceptor": "^0.14.0",
+    "undici-thread-interceptor": "^0.15.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.10.0",
-    "@platformatic/foundation": "3.10.0",
-    "@platformatic/itc": "3.10.0",
-    "@platformatic/generators": "3.10.0",
-    "@platformatic/metrics": "3.10.0",
-    "@platformatic/telemetry": "3.10.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"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.10.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.12.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -2001,6 +2001,10 @@
           "type": "number",
           "minimum": 1
         },
+        "maxTotalMemory": {
+          "type": "number",
+          "minimum": 0
+        },
         "minWorkers": {
           "type": "number",
           "minimum": 1
@@ -2019,12 +2023,11 @@
           "minimum": 0,
           "maximum": 1
         },
-        "minELUDiff": {
+        "timeWindowSec": {
           "type": "number",
-          "minimum": 0,
-          "maximum": 1
+          "minimum": 0
         },
-        "timeWindowSec": {
+        "scaleDownTimeWindowSec": {
           "type": "number",
           "minimum": 0
         },
@@ -2180,6 +2183,34 @@
           "callbackUrl"
         ]
       }
+    },
+    "policies": {
+      "type": "object",
+      "properties": {
+        "deny": {
+          "type": "object",
+          "patternProperties": {
+            "^.*$": {
+              "oneOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  },
+                  "minItems": 1
+                }
+              ]
+            }
+          }
+        }
+      },
+      "required": [
+        "deny"
+      ],
+      "additionalProperties": false
     }
   },
   "anyOf": [