@platformatic/runtime 3.8.0 → 3.10.0

package/config.d.ts

@@ -31,10 +31,39 @@ export type PlatformaticRuntimeConfig = {
           maxHeapTotal?: number | string;
           maxYoungGeneration?: number | string;
         };
-        preload?: string | string[];
         dependencies?: string[];
         arguments?: string[];
+        env?: {
+          [k: string]: string;
+        };
+        envfile?: string;
+        sourceMaps?: boolean;
+        packageManager?: "npm" | "pnpm" | "yarn";
+        preload?: string | string[];
         nodeOptions?: string;
+        permissions?: {
+          fs?: {
+            read?: string[];
+            write?: string[];
+          };
+        };
+        telemetry?: {
+          /**
+           * An array of instrumentations loaded if telemetry is enabled
+           */
+          instrumentations?: (
+            | string
+            | {
+                package: string;
+                exportName?: string;
+                options?: {
+                  [k: string]: unknown;
+                };
+                [k: string]: unknown;
+              }
+          )[];
+          [k: string]: unknown;
+        };
       };
     };
   };
@@ -255,6 +284,7 @@ export type PlatformaticRuntimeConfig = {
               };
             };
         plugins?: string[];
+        timeout?: number | string;
       };
   telemetry?: {
     enabled?: boolean | string;
@@ -343,6 +373,7 @@ export type PlatformaticRuntimeConfig = {
     timeWindowSec?: number;
     cooldownSec?: number;
     scaleIntervalSec?: number;
+    gracePeriod?: number;
     applications?: {
       [k: string]: {
         minWorkers?: number;

package/lib/config.js

@@ -45,7 +45,7 @@ function raiseInvalidWorkersError (location, received, hint) {
   throw new InvalidArgumentError(`${location} workers must be a positive integer; received "${received}"${extra}`)
 }
 
-export function autoDetectPprofCapture (config) {
+export function pprofCapturePreloadPath () {
   const require = createRequire(import.meta.url)
 
   let pprofCapturePath
@@ -55,6 +55,12 @@ export function autoDetectPprofCapture (config) {
     // No-op
   }
 
+  return pprofCapturePath
+}
+
+export function autoDetectPprofCapture (config) {
+  const pprofCapturePath = pprofCapturePreloadPath()
+
   // Add to preload if not already present
   if (!config.preload) {
     config.preload = []
@@ -192,14 +198,7 @@ export async function transform (config, _, context) {
         config = join(entryPath, configFilename)
       }
 
-      const application = {
-        id,
-        config,
-        path: entryPath,
-        useHttp: !!mapping.useHttp,
-        health: mapping.health,
-        dependencies: mapping.dependencies
-      }
+      const application = { id, config, path: entryPath, ...mapping }
       const existingApplicationId = applications.findIndex(application => application.id === id)
 
       if (existingApplicationId !== -1) {
@@ -336,6 +335,13 @@ export async function transform (config, _, context) {
     // like adding other applications.
   }
 
+  if (config.metrics === true) {
+    config.metrics = {
+      enabled: true,
+      timeout: 1000
+    }
+  }
+
   config.applications = applications
   config.web = undefined
   config.services = undefined

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,7 +9,6 @@ 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'
@@ -17,13 +16,15 @@ import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { STATUS_CODES } from 'node:http'
 import { createRequire } from 'node:module'
-import { join } from 'node:path'
+import os from 'node:os'
+import { dirname, isAbsolute, join } from 'node:path'
 import { setImmediate as immediate, setTimeout as sleep } from 'node:timers/promises'
 import { pathToFileURL } from 'node:url'
 import { Worker } from 'node:worker_threads'
 import SonicBoom from 'sonic-boom'
 import { Agent, request, interceptors as undiciInterceptors } from 'undici'
 import { createThreadInterceptor } from 'undici-thread-interceptor'
+import { pprofCapturePreloadPath } from './config.js'
 import {
   ApplicationAlreadyStartedError,
   ApplicationNotFoundError,
@@ -40,12 +41,12 @@ import {
 import { abstractLogger, createLogger } from './logger.js'
 import { startManagementApi } from './management-api.js'
 import { startPrometheusServer } from './prom-server.js'
+import ScalingAlgorithm from './scaling-algorithm.js'
 import { startScheduler } from './scheduler.js'
 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,
@@ -57,7 +58,8 @@ import {
   kStderrMarker,
   kWorkerId,
   kWorkersBroadcast,
-  kWorkerStatus
+  kWorkerStatus,
+  kWorkerStartTime
 } from './worker/symbols.js'
 
 const kWorkerFile = join(import.meta.dirname, 'worker/main.js')
@@ -277,7 +279,7 @@ export class Runtime extends EventEmitter {
     }
 
     if (this.#config.verticalScaler?.enabled) {
-      this.#setupVerticalScaler()
+      await this.#setupVerticalScaler()
     }
 
     this.#showUrl()
@@ -562,11 +564,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) {
@@ -891,8 +893,12 @@ export class Runtime extends EventEmitter {
           continue
         }
 
-        const applicationMetrics = await sendViaITC(worker, 'getMetrics', format)
-        if (applicationMetrics) {
+        const applicationMetrics = await executeWithTimeout(
+          sendViaITC(worker, 'getMetrics', format),
+          this.#config.metrics?.timeout ?? 10000
+        )
+
+        if (applicationMetrics && applicationMetrics !== kTimeout) {
           if (metrics === null) {
             metrics = format === 'json' ? [] : ''
           }
@@ -1315,6 +1321,17 @@ export class Runtime extends EventEmitter {
       execArgv.push('--enable-source-maps')
     }
 
+    if (applicationConfig.permissions?.fs) {
+      execArgv.push(...this.#setupPermissions(applicationConfig))
+    }
+
+    let preload = config.preload
+    if (execArgv.includes('--permission')) {
+      // Remove wattpm-pprof-capture from preload since it is not supported
+      const pprofCapturePath = pprofCapturePreloadPath()
+      preload = preload.filter(p => p !== pprofCapturePath)
+    }
+
     const workerEnv = structuredClone(this.#env)
 
     if (applicationConfig.nodeOptions?.trim().length > 0) {
@@ -1337,7 +1354,10 @@ export class Runtime extends EventEmitter {
 
     const worker = new Worker(kWorkerFile, {
       workerData: {
-        config,
+        config: {
+          ...config,
+          preload
+        },
         applicationConfig: {
           ...applicationConfig,
           isProduction: this.#isProduction,
@@ -1642,6 +1662,8 @@ export class Runtime extends EventEmitter {
       }
 
       worker[kWorkerStatus] = 'started'
+      worker[kWorkerStartTime] = Date.now()
+
       this.emitAndNotify('application:worker:started', eventPayload)
       this.#broadcastWorkers()
 
@@ -2441,9 +2463,14 @@ export class Runtime extends EventEmitter {
     }
   }
 
-  #setupVerticalScaler () {
-    const isWorkersFixed = this.#config.workers !== undefined
-    if (isWorkersFixed) return
+  async #setupVerticalScaler () {
+    const fixedWorkersCount = this.#config.workers
+    if (fixedWorkersCount !== undefined) {
+      this.logger.warn(
+        `Vertical scaler disabled because the "workers" configuration is set to ${fixedWorkersCount}`
+      )
+      return
+    }
 
     const scalerConfig = this.#config.verticalScaler
 
@@ -2456,6 +2483,7 @@ export class Runtime extends EventEmitter {
     scalerConfig.minELUDiff ??= 0.2
     scalerConfig.scaleIntervalSec ??= 60
     scalerConfig.timeWindowSec ??= 60
+    scalerConfig.gracePeriod ??= 30 * 1000
     scalerConfig.applications ??= {}
 
     const maxTotalWorkers = scalerConfig.maxTotalWorkers
@@ -2468,9 +2496,18 @@ export class Runtime extends EventEmitter {
     const scaleIntervalSec = scalerConfig.scaleIntervalSec
     const timeWindowSec = scalerConfig.timeWindowSec
     const applicationsConfigs = scalerConfig.applications
+    const gracePeriod = scalerConfig.gracePeriod
+    const healthCheckInterval = 1000
+
+    const initialResourcesUpdates = []
 
     for (const application of this.#config.applications) {
       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.'
+        )
+
         applicationsConfigs[application.id] = {
           minWorkers: 1,
           maxWorkers: 1
@@ -2478,6 +2515,10 @@ export class Runtime extends EventEmitter {
         continue
       }
       if (application.workers !== undefined) {
+        this.logger.warn(
+          `The "${application.id}" application cannot be scaled because` +
+          ` it has a fixed number of workers (${application.workers}).`
+        )
         applicationsConfigs[application.id] = {
           minWorkers: application.workers,
           maxWorkers: application.workers
@@ -2488,12 +2529,22 @@ export class Runtime extends EventEmitter {
       applicationsConfigs[application.id] ??= {}
       applicationsConfigs[application.id].minWorkers ??= minWorkers
       applicationsConfigs[application.id].maxWorkers ??= maxWorkers
+
+      const appMinWorkers = applicationsConfigs[application.id].minWorkers
+      if (appMinWorkers > 1) {
+        initialResourcesUpdates.push({
+          application: application.id,
+          workers: minWorkers
+        })
+      }
+    }
+
+    if (initialResourcesUpdates.length > 0) {
+      await this.updateApplicationsResources(initialResourcesUpdates)
     }
 
     for (const applicationId in applicationsConfigs) {
-      const application = this.#config.applications.find(
-        app => app.id === applicationId
-      )
+      const application = this.#config.applications.find(app => app.id === applicationId)
       if (!application) {
         delete applicationsConfigs[applicationId]
 
@@ -2512,18 +2563,43 @@ export class Runtime extends EventEmitter {
       applications: applicationsConfigs
     })
 
-    this.on('application:worker:health', async (healthInfo) => {
-      if (!healthInfo) {
-        this.logger.error('No health info received')
-        return
-      }
+    const healthCheckTimeout = setTimeout(async () => {
+      let shouldCheckForScaling = false
+
+      const now = Date.now()
 
-      scalingAlgorithm.addWorkerHealthInfo(healthInfo)
+      for (const worker of this.#workers.values()) {
+        if (
+          worker[kWorkerStatus] !== 'started' ||
+          worker[kWorkerStartTime] + gracePeriod > now
+        ) {
+          continue
+        }
+
+        try {
+          const health = await this.#getHealth(worker)
+          if (!health) continue
+
+          scalingAlgorithm.addWorkerHealthInfo({
+            workerId: worker[kId],
+            applicationId: worker[kApplicationId],
+            elu: health.elu
+          })
 
-      if (healthInfo.currentHealth.elu > scaleUpELU) {
+          if (health.elu > scaleUpELU) {
+            shouldCheckForScaling = true
+          }
+        } catch (err) {
+          this.logger.error({ err }, 'Failed to get health for worker')
+        }
+      }
+
+      if (shouldCheckForScaling) {
         await checkForScaling()
       }
-    })
+
+      healthCheckTimeout.refresh()
+    }, healthCheckInterval).unref()
 
     let isScaling = false
     let lastScaling = 0
@@ -2548,16 +2624,16 @@ export class Runtime extends EventEmitter {
         const recommendations = scalingAlgorithm.getRecommendations(appsWorkersInfo)
         if (recommendations.length > 0) {
           await applyRecommendations(recommendations)
+          lastScaling = Date.now()
         }
       } catch (err) {
         this.logger.error({ err }, 'Failed to scale applications')
       } finally {
         isScaling = false
-        lastScaling = Date.now()
       }
     }
 
-    const applyRecommendations = async (recommendations) => {
+    const applyRecommendations = async recommendations => {
       const resourcesUpdates = []
       for (const recommendation of recommendations) {
         const { applicationId, workersCount, direction } = recommendation
@@ -2574,4 +2650,48 @@ export class Runtime extends EventEmitter {
     // Interval for periodic scaling checks
     setInterval(checkForScaling, scaleIntervalSec * 1000).unref()
   }
+
+  #setupPermissions (applicationConfig) {
+    const argv = []
+    const allows = new Set()
+    const { read, write } = applicationConfig.permissions.fs
+
+    if (read?.length) {
+      for (const p of read) {
+        allows.add(`--allow-fs-read=${isAbsolute(p) ? p : join(applicationConfig.path, p)}`)
+      }
+    }
+
+    if (write?.length) {
+      for (const p of write) {
+        allows.add(`--allow-fs-write=${isAbsolute(p) ? p : join(applicationConfig.path, p)}`)
+      }
+    }
+
+    if (allows.size === 0) {
+      return argv
+    }
+
+    // We need to allow read access to the node_modules folder both at the runtime level and at the application level
+    allows.add(`--allow-fs-read=${join(this.#root, 'node_modules', '*')}`)
+    allows.add(`--allow-fs-read=${join(applicationConfig.path, 'node_modules', '*')}`)
+
+    // Since we can't really predict how dependencies are installed (symlinks, pnpm store, and so forth), we also
+    // add any node_modules folder found in the ancestors of the current file
+    let lastPath = import.meta.dirname
+    let currentPath = import.meta.dirname
+
+    do {
+      lastPath = currentPath
+      const nodeModules = join(currentPath, 'node_modules')
+      if (existsSync(nodeModules)) {
+        allows.add(`--allow-fs-read=${join(nodeModules, '*')}`)
+      }
+
+      currentPath = dirname(currentPath)
+    } while (lastPath !== currentPath)
+
+    argv.push('--permission', ...allows)
+    return argv
+  }
 }

package/lib/scaling-algorithm.js

@@ -19,9 +19,7 @@ class ScalingAlgorithm {
   }
 
   addWorkerHealthInfo (healthInfo) {
-    const workerId = healthInfo.id
-    const applicationId = healthInfo.application
-    const elu = healthInfo.currentHealth.elu
+    const { workerId, applicationId, elu } = healthInfo
     const timestamp = Date.now()
 
     if (!this.#appsELUs[applicationId]) {
@@ -59,6 +57,27 @@ class ScalingAlgorithm {
 
     for (const { applicationId, elu, workersCount } 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'
+        })
+        totalWorkersCount += appMinWorkers - workersCount
+        continue
+      }
+
+      if (workersCount > appMaxWorkers) {
+        recommendations.push({
+          applicationId,
+          workersCount: appMaxWorkers,
+          direction: 'down'
+        })
+        totalWorkersCount -= workersCount - appMaxWorkers
+        continue
+      }
 
       if (elu < this.#scaleDownELU && workersCount > appMinWorkers) {
         recommendations.push({
@@ -75,6 +94,12 @@ class ScalingAlgorithm {
 
       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
 

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/lib/worker/symbols.js

@@ -6,6 +6,7 @@ export const kWorkerId = Symbol.for('plt.runtime.worker.id')
 export const kITC = Symbol.for('plt.runtime.itc')
 export const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer')
 export const kWorkerStatus = Symbol('plt.runtime.worker.status')
+export const kWorkerStartTime = Symbol.for('plt.runtime.worker.startTime')
 export const kInterceptors = Symbol.for('plt.runtime.worker.interceptors')
 export const kLastELU = Symbol.for('plt.runtime.worker.lastELU')
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.8.0",
+  "version": "3.10.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.8.0",
-    "@platformatic/db": "3.8.0",
-    "@platformatic/gateway": "3.8.0",
-    "@platformatic/node": "3.8.0",
-    "@platformatic/sql-graphql": "3.8.0",
-    "@platformatic/service": "3.8.0",
-    "@platformatic/sql-mapper": "3.8.0",
-    "@platformatic/wattpm-pprof-capture": "3.8.0"
+    "@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"
   },
   "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/basic": "3.8.0",
-    "@platformatic/foundation": "3.8.0",
-    "@platformatic/itc": "3.8.0",
-    "@platformatic/metrics": "3.8.0",
-    "@platformatic/generators": "3.8.0",
-    "@platformatic/telemetry": "3.8.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"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.8.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.10.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -171,6 +171,40 @@
                 },
                 "additionalProperties": false
               },
+              "dependencies": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                },
+                "default": []
+              },
+              "arguments": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "env": {
+                "type": "object",
+                "additionalProperties": {
+                  "type": "string"
+                }
+              },
+              "envfile": {
+                "type": "string"
+              },
+              "sourceMaps": {
+                "type": "boolean",
+                "default": false
+              },
+              "packageManager": {
+                "type": "string",
+                "enum": [
+                  "npm",
+                  "pnpm",
+                  "yarn"
+                ]
+              },
               "preload": {
                 "anyOf": [
                   {
@@ -186,20 +220,66 @@
                   }
                 ]
               },
-              "dependencies": {
-                "type": "array",
-                "items": {
-                  "type": "string"
-                }
-              },
-              "arguments": {
-                "type": "array",
-                "items": {
-                  "type": "string"
-                }
-              },
               "nodeOptions": {
                 "type": "string"
+              },
+              "permissions": {
+                "type": "object",
+                "properties": {
+                  "fs": {
+                    "type": "object",
+                    "properties": {
+                      "read": {
+                        "type": "array",
+                        "items": {
+                          "type": "string"
+                        }
+                      },
+                      "write": {
+                        "type": "array",
+                        "items": {
+                          "type": "string"
+                        }
+                      }
+                    },
+                    "additionalProperties": false
+                  }
+                },
+                "additionalProperties": false
+              },
+              "telemetry": {
+                "type": "object",
+                "properties": {
+                  "instrumentations": {
+                    "type": "array",
+                    "description": "An array of instrumentations loaded if telemetry is enabled",
+                    "items": {
+                      "oneOf": [
+                        {
+                          "type": "string"
+                        },
+                        {
+                          "type": "object",
+                          "properties": {
+                            "package": {
+                              "type": "string"
+                            },
+                            "exportName": {
+                              "type": "string"
+                            },
+                            "options": {
+                              "type": "object",
+                              "additionalProperties": true
+                            }
+                          },
+                          "required": [
+                            "package"
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                }
               }
             }
           }
@@ -405,6 +485,30 @@
           "nodeOptions": {
             "type": "string"
           },
+          "permissions": {
+            "type": "object",
+            "properties": {
+              "fs": {
+                "type": "object",
+                "properties": {
+                  "read": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "write": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "additionalProperties": false
+              }
+            },
+            "additionalProperties": false
+          },
           "telemetry": {
             "type": "object",
             "properties": {
@@ -641,6 +745,30 @@
           "nodeOptions": {
             "type": "string"
           },
+          "permissions": {
+            "type": "object",
+            "properties": {
+              "fs": {
+                "type": "object",
+                "properties": {
+                  "read": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "write": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "additionalProperties": false
+              }
+            },
+            "additionalProperties": false
+          },
           "telemetry": {
             "type": "object",
             "properties": {
@@ -877,6 +1005,30 @@
           "nodeOptions": {
             "type": "string"
           },
+          "permissions": {
+            "type": "object",
+            "properties": {
+              "fs": {
+                "type": "object",
+                "properties": {
+                  "read": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  },
+                  "write": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                },
+                "additionalProperties": false
+              }
+            },
+            "additionalProperties": false
+          },
           "telemetry": {
             "type": "object",
             "properties": {
@@ -1691,6 +1843,17 @@
                   }
                 ]
               }
+            },
+            "timeout": {
+              "anyOf": [
+                {
+                  "type": "integer"
+                },
+                {
+                  "type": "string"
+                }
+              ],
+              "default": 10000
             }
           },
           "additionalProperties": false
@@ -1873,6 +2036,10 @@
           "type": "number",
           "minimum": 0
         },
+        "gracePeriod": {
+          "type": "number",
+          "minimum": 0
+        },
         "applications": {
           "type": "object",
           "additionalProperties": {