@platformatic/runtime 3.0.0-alpha.6 → 3.0.0-alpha.8

package/config.d.ts

@@ -32,6 +32,7 @@ export type PlatformaticRuntimeConfig = {
           maxYoungGeneration?: number | string;
         };
         preload?: string | string[];
+        dependencies?: string[];
         arguments?: string[];
         nodeOptions?: string;
       };

package/lib/config.js

@@ -16,12 +16,59 @@ import {
   InspectAndInspectBrkError,
   InspectorHostError,
   InspectorPortError,
+  InvalidArgumentError,
   InvalidEntrypointError,
   MissingEntrypointError
 } from './errors.js'
 import { schema } from './schema.js'
 import { upgrade } from './upgrade.js'
 
+// Validate and coerce workers values early to avoid runtime hangs when invalid
+function coercePositiveInteger (value) {
+  if (typeof value === 'number') {
+    if (!Number.isInteger(value) || value < 1) return null
+    return value
+  }
+  if (typeof value === 'string') {
+    // Trim to handle accidental spaces
+    const trimmed = value.trim()
+    if (trimmed.length === 0) return null
+    const num = Number(trimmed)
+    if (!Number.isFinite(num) || !Number.isInteger(num) || num < 1) return null
+    return num
+  }
+  return null
+}
+
+function raiseInvalidWorkersError (location, received, hint) {
+  const extra = hint ? ` (${hint})` : ''
+  throw new InvalidArgumentError(`${location} workers must be a positive integer; received "${received}"${extra}`)
+}
+
+export function autoDetectPprofCapture (config) {
+  const require = createRequire(import.meta.url)
+
+  let pprofCapturePath
+  try {
+    pprofCapturePath = require.resolve('@platformatic/wattpm-pprof-capture')
+  } catch (err) {
+    // No-op
+  }
+
+  // Add to preload if not already present
+  if (!config.preload) {
+    config.preload = []
+  } else if (typeof config.preload === 'string') {
+    config.preload = [config.preload]
+  }
+
+  if (pprofCapturePath && !config.preload.includes(pprofCapturePath)) {
+    config.preload.push(pprofCapturePath)
+  }
+
+  return config
+}
+
 export async function wrapInRuntimeConfig (config, context) {
   let applicationId = 'main'
   try {
@@ -145,7 +192,14 @@ export async function transform (config, _, context) {
         config = join(entryPath, configFilename)
       }
 
-      const application = { id, config, path: entryPath, useHttp: !!mapping.useHttp, health: mapping.health }
+      const application = {
+        id,
+        config,
+        path: entryPath,
+        useHttp: !!mapping.useHttp,
+        health: mapping.health,
+        dependencies: mapping.dependencies
+      }
       const existingApplicationId = applications.findIndex(application => application.id === id)
 
       if (existingApplicationId !== -1) {
@@ -161,6 +215,17 @@ export async function transform (config, _, context) {
 
   let hasValidEntrypoint = false
 
+  // Root-level workers
+  if (typeof config.workers !== 'undefined') {
+    const coerced = coercePositiveInteger(config.workers)
+    if (coerced === null) {
+      const raw = config.workers
+      const hint = typeof raw === 'string' && /\{.*\}/.test(raw) ? 'check your environment variable' : ''
+      raiseInvalidWorkersError('Runtime', config.workers, hint)
+    }
+    config.workers = coerced
+  }
+
   for (let i = 0; i < applications.length; ++i) {
     const application = applications[i]
 
@@ -207,8 +272,19 @@ export async function transform (config, _, context) {
       application.type = 'unknown'
     }
 
+    // Validate and coerce per-service workers
+    if (typeof application.workers !== 'undefined') {
+      const coerced = coercePositiveInteger(application.workers)
+      if (coerced === null) {
+        const raw = config.application?.[i]?.workers
+        const hint = typeof raw === 'string' && /\{.*\}/.test(raw) ? 'check your environment variable' : ''
+        raiseInvalidWorkersError(`Service "${application.id}"`, application.workers, hint)
+      }
+      application.workers = coerced
+    }
+
     application.entrypoint = application.id === config.entrypoint
-    application.dependencies = []
+    application.dependencies ??= []
     application.localUrl = `http://${application.id}.plt.local`
 
     if (typeof application.watch === 'undefined') {
@@ -277,5 +353,8 @@ export async function transform (config, _, context) {
     }
   }
 
+  // Auto-detect and add pprof capture if available
+  autoDetectPprofCapture(config)
+
   return config
 }

package/lib/management-api.js

@@ -4,6 +4,7 @@ import { createDirectory, safeRemove } from '@platformatic/foundation'
 import fastify from 'fastify'
 import { platform, tmpdir } from 'node:os'
 import { join } from 'node:path'
+import { setTimeout as sleep } from 'node:timers/promises'
 import { createWebSocketStream } from 'ws'
 
 const PLATFORMATIC_TMP_DIR = join(tmpdir(), 'platformatic', 'runtimes')
@@ -111,6 +112,23 @@ export async function managementApiPlugin (app, opts) {
     reply.code(res.statusCode).headers(res.headers).send(res.body)
   })
 
+  app.post('/applications/:id/pprof/start', async (request, reply) => {
+    const { id } = request.params
+    app.log.debug('start profiling', { id })
+
+    const options = request.body || {}
+    await runtime.startApplicationProfiling(id, options)
+    reply.code(200).send({})
+  })
+
+  app.post('/applications/:id/pprof/stop', async (request, reply) => {
+    const { id } = request.params
+    app.log.debug('stop profiling', { id })
+
+    const profileData = await runtime.stopApplicationProfiling(id)
+    reply.type('application/octet-stream').code(200).send(profileData)
+  })
+
   app.get('/metrics', { logLevel: 'debug' }, async (req, reply) => {
     const accepts = req.accepts()
 
@@ -152,40 +170,53 @@ export async function managementApiPlugin (app, opts) {
   })
 }
 
-export async function startManagementApi (runtime, root) {
+export async function startManagementApi (runtime) {
   const runtimePID = process.pid
 
-  try {
-    const runtimePIDDir = join(PLATFORMATIC_TMP_DIR, runtimePID.toString())
+  const runtimePIDDir = join(PLATFORMATIC_TMP_DIR, runtimePID.toString())
+  if (platform() !== 'win32') {
+    await createDirectory(runtimePIDDir, true)
+  }
+
+  let socketPath = null
+  if (platform() === 'win32') {
+    socketPath = '\\\\.\\pipe\\platformatic-' + runtimePID.toString()
+  } else {
+    socketPath = join(runtimePIDDir, 'socket')
+  }
+
+  const managementApi = fastify()
+  managementApi.register(fastifyWebsocket)
+  managementApi.register(managementApiPlugin, { runtime, prefix: '/api/v1' })
+
+  managementApi.addHook('onClose', async () => {
     if (platform() !== 'win32') {
-      await createDirectory(runtimePIDDir, true)
+      await safeRemove(runtimePIDDir)
     }
+  })
 
-    let socketPath = null
-    if (platform() === 'win32') {
-      socketPath = '\\\\.\\pipe\\platformatic-' + runtimePID.toString()
-    } else {
-      socketPath = join(runtimePIDDir, 'socket')
-    }
+  // When the runtime closes, close the management API as well
+  runtime.on('closed', managementApi.close.bind(managementApi))
 
-    const managementApi = fastify()
-    managementApi.register(fastifyWebsocket)
-    managementApi.register(managementApiPlugin, { runtime, prefix: '/api/v1' })
+  /*
+    If runtime are started multiple times in a short
+    period of time (like in tests), there is a chance that the pipe is still in use
+    as the manament API server is closed after the runtime is closed (see event handler above).
 
-    managementApi.addHook('onClose', async () => {
-      if (platform() !== 'win32') {
-        await safeRemove(runtimePIDDir)
+    Since it's a very rare case, we simply retry couple of times.
+  */
+  for (let i = 0; i < 5; i++) {
+    try {
+      await managementApi.listen({ path: socketPath })
+      break
+    } catch (e) {
+      if (i === 5) {
+        throw e
       }
-    })
-
-    // When the runtime closes, close the management API as well
-    runtime.on('closed', managementApi.close.bind(managementApi))
 
-    await managementApi.listen({ path: socketPath })
-    return managementApi
-    /* c8 ignore next 4 */
-  } catch (err) {
-    console.error(err)
-    process.exit(1)
+      await sleep(100)
+    }
   }
+
+  return managementApi
 }

package/lib/runtime.js

@@ -2,6 +2,7 @@ import {
   deepmerge,
   ensureError,
   ensureLoggableError,
+  executeInParallel,
   executeWithTimeout,
   features,
   kMetadata,
@@ -22,7 +23,6 @@ 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 { checkDependencies, topologicalSort } from './dependencies.js'
 import {
   ApplicationAlreadyStartedError,
   ApplicationNotFoundError,
@@ -59,18 +59,20 @@ import {
 
 const kWorkerFile = join(import.meta.dirname, 'worker/main.js')
 const kInspectorOptions = Symbol('plt.runtime.worker.inspectorOptions')
-const kForwardEvents = Symbol('plt.runtime.worker.forwardEvents')
 
 const MAX_LISTENERS_COUNT = 100
 const MAX_METRICS_QUEUE_LENGTH = 5 * 60 // 5 minutes in seconds
 const COLLECT_METRICS_TIMEOUT = 1000
 
+const MAX_CONCURRENCY = 5
 const MAX_BOOTSTRAP_ATTEMPTS = 5
 const IMMEDIATE_RESTART_MAX_THRESHOLD = 10
 const MAX_WORKERS = 100
 
 export class Runtime extends EventEmitter {
   logger
+  error
+
   #loggerDestination
   #stdio
 
@@ -81,6 +83,7 @@ export class Runtime extends EventEmitter {
   #context
   #sharedContext
   #isProduction
+  #concurrency
   #entrypointId
   #url
 
@@ -112,6 +115,7 @@ export class Runtime extends EventEmitter {
     this.#env = config[kMetadata].env
     this.#context = context ?? {}
     this.#isProduction = this.#context.isProduction ?? this.#context.production ?? false
+    this.#concurrency = this.#context.concurrency ?? MAX_CONCURRENCY
     this.#workers = new RoundRobinMap()
     this.#url = undefined
     this.#meshInterceptor = createThreadInterceptor({ domain: '.plt.local', timeout: this.#config.applicationTimeout })
@@ -150,7 +154,6 @@ export class Runtime extends EventEmitter {
     }
 
     const config = this.#config
-    const autoloadEnabled = config.autoload
 
     if (config.managementApi) {
       this.#managementApi = await startManagementApi(this, this.#root)
@@ -190,61 +193,7 @@ export class Runtime extends EventEmitter {
       this.#env['PLT_ENVIRONMENT'] = 'development'
     }
 
-    // Create all applications, each in is own worker thread
-    for (const applicationConfig of config.applications) {
-      // If there is no application path, check if the application was resolved
-      if (!applicationConfig.path) {
-        if (applicationConfig.url) {
-          // Try to backfill the path for external applications
-          applicationConfig.path = join(this.#root, config.resolvedApplicationsBasePath, applicationConfig.id)
-
-          if (!existsSync(applicationConfig.path)) {
-            const executable = globalThis.platformatic?.executable ?? 'platformatic'
-            this.logger.error(
-              `The path for application "%s" does not exist. Please run "${executable} resolve" and try again.`,
-              applicationConfig.id
-            )
-
-            await this.closeAndThrow(new RuntimeAbortedError())
-          }
-        } else {
-          this.logger.error(
-            'The application "%s" has no path defined. Please check your configuration and try again.',
-            applicationConfig.id
-          )
-
-          await this.closeAndThrow(new RuntimeAbortedError())
-        }
-      }
-
-      await this.#setupApplication(applicationConfig)
-    }
-
-    try {
-      checkDependencies(config.applications)
-
-      // Make sure the list exists before computing the dependencies, otherwise some applications might not be stopped
-      if (autoloadEnabled) {
-        this.#workers = topologicalSort(this.#workers, config)
-      }
-
-      // When autoloading is disabled, add a warning if an application is defined before its dependencies
-      if (!autoloadEnabled) {
-        for (let i = 0; i < config.applications.length; i++) {
-          const current = config.applications[i]
-
-          for (const dep of current.dependencies ?? []) {
-            if (config.applications.findIndex(s => s.id === dep.id) > i) {
-              this.logger.warn(
-                `Application "${current.id}" depends on application "${dep.id}", but it is defined and it will be started before it. Please check your configuration file.`
-              )
-            }
-          }
-        }
-      }
-    } catch (e) {
-      await this.closeAndThrow(e)
-    }
+    await this.#setupApplications()
 
     await this.#setDispatcher(config.undici)
 
@@ -266,12 +215,14 @@ export class Runtime extends EventEmitter {
     this.#updateStatus('starting')
     this.#createWorkersBroadcastChannel()
 
-    // Important: do not use Promise.all here since it won't properly manage dependencies
     try {
+      const startInvocations = []
       for (const application of this.getApplicationsIds()) {
-        await this.startApplication(application, silent)
+        startInvocations.push([application, silent])
       }
 
+      await executeInParallel(this.startApplication.bind(this), startInvocations, this.#concurrency)
+
       if (this.#config.inspectorOptions) {
         const { port } = this.#config.inspectorOptions
 
@@ -340,16 +291,35 @@ export class Runtime extends EventEmitter {
       await this.stopApplication(this.#entrypointId, silent)
     }
 
-    // Stop applications in reverse order to ensure applications which depend on others are stopped first
-    for (const application of this.getApplicationsIds().reverse()) {
+    const stopInvocations = []
+
+    const allApplications = await this.getApplications(true)
+
+    // Construct the reverse dependency graph
+    const dependents = {}
+    for (const application of allApplications.applications) {
+      for (const dependency of application.dependencies ?? []) {
+        let applicationDependents = dependents[dependency]
+        if (!applicationDependents) {
+          applicationDependents = new Set()
+          dependents[dependency] = applicationDependents
+        }
+
+        applicationDependents.add(application.id)
+      }
+    }
+
+    for (const application of this.getApplicationsIds()) {
       // The entrypoint has been stopped above
       if (application === this.#entrypointId) {
         continue
       }
 
-      await this.stopApplication(application, silent)
+      stopInvocations.push([application, silent, Array.from(dependents[application] ?? [])])
     }
 
+    await executeInParallel(this.stopApplication.bind(this), stopInvocations, this.#concurrency)
+
     await this.#meshInterceptor.close()
     this.#workersBroadcastChannel?.close()
 
@@ -397,6 +367,7 @@ export class Runtime extends EventEmitter {
 
   async closeAndThrow (error) {
     this.#updateStatus('errored', error)
+    this.error = error
 
     // Wait for the next tick so that any pending logging is properly flushed
     await sleep(1)
@@ -452,9 +423,7 @@ export class Runtime extends EventEmitter {
 
   emit (event, payload) {
     for (const worker of this.#workers.values()) {
-      if (worker[kForwardEvents]) {
-        worker[kITC].notify('runtime:event', { event, payload })
-      }
+      worker[kITC].notify('runtime:event', { event, payload })
     }
 
     this.logger.trace({ event, payload }, 'Runtime event')
@@ -502,7 +471,7 @@ export class Runtime extends EventEmitter {
     this.emit('application:started', id)
   }
 
-  async stopApplication (id, silent = false) {
+  async stopApplication (id, silent = false, dependents = []) {
     const config = this.#config
     const applicationConfig = config.applications.find(s => s.id === id)
 
@@ -515,9 +484,12 @@ export class Runtime extends EventEmitter {
     this.emit('application:stopping', id)
 
     if (typeof workersCount === 'number') {
+      const stopInvocations = []
       for (let i = 0; i < workersCount; i++) {
-        await this.#stopWorker(workersCount, id, i, silent)
+        stopInvocations.push([workersCount, id, i, silent, undefined, dependents])
       }
+
+      await executeInParallel(this.#stopWorker.bind(this), stopInvocations, this.#concurrency)
     }
 
     this.emit('application:stopped', id)
@@ -540,6 +512,18 @@ export class Runtime extends EventEmitter {
     }
   }
 
+  async startApplicationProfiling (id, options = {}, ensureStarted = true) {
+    const service = await this.#getApplicationById(id, ensureStarted)
+
+    return sendViaITC(service, 'startProfiling', options)
+  }
+
+  async stopApplicationProfiling (id, ensureStarted = true) {
+    const service = await this.#getApplicationById(id, ensureStarted)
+
+    return sendViaITC(service, 'stopProfiling')
+  }
+
   async updateUndiciInterceptors (undiciConfig) {
     this.#config.undici = undiciConfig
 
@@ -754,6 +738,10 @@ export class Runtime extends EventEmitter {
     return report
   }
 
+  setConcurrency (concurrency) {
+    this.#concurrency = concurrency
+  }
+
   async getUrl () {
     return this.#url
   }
@@ -1014,11 +1002,13 @@ export class Runtime extends EventEmitter {
     return this.#config.applications.map(application => application.id)
   }
 
-  async getApplications () {
+  async getApplications (allowUnloaded = false) {
     return {
       entrypoint: this.#entrypointId,
       production: this.#isProduction,
-      applications: await Promise.all(this.getApplicationsIds().map(id => this.getApplicationDetails(id)))
+      applications: await Promise.all(
+        this.getApplicationsIds().map(id => this.getApplicationDetails(id, allowUnloaded))
+      )
     }
   }
 
@@ -1070,19 +1060,19 @@ export class Runtime extends EventEmitter {
       throw e
     }
 
-    const { entrypoint, dependencies, localUrl } = application[kConfig]
+    const { entrypoint, localUrl } = application[kConfig]
 
     const status = await sendViaITC(application, 'getStatus')
-    const { type, version } = await sendViaITC(application, 'getApplicationInfo')
+    const { type, version, dependencies } = await sendViaITC(application, 'getApplicationInfo')
 
     const applicationDetails = {
       id,
       type,
       status,
+      dependencies,
       version,
       localUrl,
-      entrypoint,
-      dependencies
+      entrypoint
     }
 
     if (this.#isProduction) {
@@ -1175,17 +1165,59 @@ export class Runtime extends EventEmitter {
     this.logger.info(`Platformatic is now listening at ${this.#url}`)
   }
 
+  async #setupApplications () {
+    const config = this.#config
+    const setupInvocations = []
+
+    // Parse all applications and verify we're not missing any path or resolved application
+    for (const applicationConfig of config.applications) {
+      // If there is no application path, check if the application was resolved
+      if (!applicationConfig.path) {
+        if (applicationConfig.url) {
+          // Try to backfill the path for external applications
+          applicationConfig.path = join(this.#root, config.resolvedApplicationsBasePath, applicationConfig.id)
+
+          if (!existsSync(applicationConfig.path)) {
+            const executable = globalThis.platformatic?.executable ?? 'platformatic'
+            this.logger.error(
+              `The path for application "%s" does not exist. Please run "${executable} resolve" and try again.`,
+              applicationConfig.id
+            )
+
+            await this.closeAndThrow(new RuntimeAbortedError())
+          }
+        } else {
+          this.logger.error(
+            'The application "%s" has no path defined. Please check your configuration and try again.',
+            applicationConfig.id
+          )
+
+          await this.closeAndThrow(new RuntimeAbortedError())
+        }
+      }
+
+      setupInvocations.push([applicationConfig])
+    }
+
+    await executeInParallel(this.#setupApplication.bind(this), setupInvocations, this.#concurrency)
+  }
+
   async #setupApplication (applicationConfig) {
-    if (this.#status === 'stopping' || this.#status === 'closed') return
+    if (this.#status === 'stopping' || this.#status === 'closed') {
+      return
+    }
 
     const config = this.#config
     const workersCount = await this.#workers.getCount(applicationConfig.id)
     const id = applicationConfig.id
+    const setupInvocations = []
 
     for (let i = 0; i < workersCount; i++) {
-      await this.#setupWorker(config, applicationConfig, workersCount, id, i)
+      setupInvocations.push([config, applicationConfig, workersCount, id, i])
     }
 
+    await executeInParallel(this.#setupWorker.bind(this), setupInvocations, this.#concurrency)
+
     this.emit('application:init', id)
   }
 
@@ -1287,6 +1319,7 @@ export class Runtime extends EventEmitter {
 
     // Track application exiting
     const eventPayload = { application: applicationId, worker: index, workersCount }
+
     worker.once('exit', code => {
       if (worker[kWorkerStatus] === 'exited') {
         return
@@ -1338,7 +1371,6 @@ export class Runtime extends EventEmitter {
     worker[kApplicationId] = applicationId
     worker[kWorkerId] = workersCount > 1 ? index : undefined
     worker[kWorkerStatus] = 'boot'
-    worker[kForwardEvents] = false
 
     if (inspectorOptions) {
       worker[kInspectorOptions] = {
@@ -1352,12 +1384,7 @@ export class Runtime extends EventEmitter {
     worker[kITC] = new ITC({
       name: workerId + '-runtime',
       port: worker,
-      handlers: {
-        ...this.#workerITCHandlers,
-        setEventsForwarding (value) {
-          worker[kForwardEvents] = value
-        }
-      }
+      handlers: this.#workerITCHandlers
     })
     worker[kITC].listen()
 
@@ -1403,15 +1430,13 @@ export class Runtime extends EventEmitter {
       this.#meshInterceptor.route(applicationId, worker)
     }
 
-    // Store dependencies
-    const [{ dependencies }] = await waitEventFromITC(worker, 'init')
-    applicationConfig.dependencies = dependencies
+    // Wait for initialization
+    await waitEventFromITC(worker, 'init')
 
     if (applicationConfig.entrypoint) {
       this.#entrypointId = applicationId
     }
 
-    // This must be done here as the dependencies are filled above
     worker[kConfig] = { ...applicationConfig, health, workers: workersCount }
     worker[kWorkerStatus] = 'init'
     this.emit('application:worker:init', eventPayload)
@@ -1587,6 +1612,7 @@ export class Runtime extends EventEmitter {
       }
     } catch (err) {
       const error = ensureError(err)
+      worker[kITC].notify('application:worker:start:processed')
 
       // TODO: handle port allocation error here
       if (error.code === 'EADDRINUSE' || error.code === 'EACCES') throw error
@@ -1608,7 +1634,7 @@ export class Runtime extends EventEmitter {
       this.emit('application:worker:start:error', { ...eventPayload, error })
 
       if (error.code !== 'PLT_RUNTIME_APPLICATION_START_TIMEOUT') {
-        this.logger.error({ err: ensureLoggableError(error) }, `Failed to start ${label}.`)
+        this.logger.error({ err: ensureLoggableError(error) }, `Failed to start ${label}: ${error.message}`)
       }
 
       const restartOnError = config.restartOnError
@@ -1619,6 +1645,7 @@ export class Runtime extends EventEmitter {
 
       if (bootstrapAttempt++ >= MAX_BOOTSTRAP_ATTEMPTS || restartOnError === 0) {
         this.logger.error(`Failed to start ${label} after ${MAX_BOOTSTRAP_ATTEMPTS} attempts.`)
+        this.emit('application:worker:start:failed', { ...eventPayload, error })
         throw error
       }
 
@@ -1636,7 +1663,7 @@ export class Runtime extends EventEmitter {
     }
   }
 
-  async #stopWorker (workersCount, id, index, silent, worker = undefined) {
+  async #stopWorker (workersCount, id, index, silent, worker, dependents) {
     if (!worker) {
       worker = await this.#getWorkerById(id, index, false, false)
     }
@@ -1667,11 +1694,15 @@ export class Runtime extends EventEmitter {
 
     // Always send the stop message, it will shut down workers that only had ITC and interceptors setup
     try {
-      await executeWithTimeout(sendViaITC(worker, 'stop'), exitTimeout)
+      await executeWithTimeout(sendViaITC(worker, 'stop', { force: !!this.error, dependents }), exitTimeout)
     } catch (error) {
-      this.emit('application:worker:stop:timeout', eventPayload)
+      this.emit('application:worker:stop:error', eventPayload)
       this.logger.info({ error: ensureLoggableError(error) }, `Failed to stop ${label}. Killing a worker thread.`)
     } finally {
+      worker[kITC].notify('application:worker:stop:processed')
+      // Wait for the processed message to be received
+      await sleep(1)
+
       worker[kITC].close()
     }
 
@@ -1800,7 +1831,7 @@ export class Runtime extends EventEmitter {
       throw e
     }
 
-    await this.#stopWorker(workersCount, applicationId, index, false, worker)
+    await this.#stopWorker(workersCount, applicationId, index, false, worker, [])
   }
 
   async #getApplicationById (applicationId, ensureStarted = false, mustExist = true) {
@@ -2323,7 +2354,7 @@ export class Runtime extends EventEmitter {
         for (let i = currentWorkers - 1; i >= workers; i--) {
           const worker = await this.#getWorkerById(applicationId, i, false, false)
           await sendViaITC(worker, 'removeFromMesh')
-          await this.#stopWorker(currentWorkers, applicationId, i, false, worker)
+          await this.#stopWorker(currentWorkers, applicationId, i, false, worker, [])
           report.stopped.push(i)
         }
         await this.#updateApplicationConfigWorkers(applicationId, workers)

package/lib/worker/controller.js

@@ -1,6 +1,7 @@
 import {
   ensureLoggableError,
   FileWatcher,
+  kHandledError,
   listRecognizedConfigurationFiles,
   loadConfiguration,
   loadConfigurationModule
@@ -9,6 +10,7 @@ import debounce from 'debounce'
 import { EventEmitter } from 'node:events'
 import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
+import { getActiveResourcesInfo } from 'node:process'
 import { workerData } from 'node:worker_threads'
 import { getGlobalDispatcher, setGlobalDispatcher } from 'undici'
 import { ApplicationAlreadyStartedError, RuntimeNotStartedError } from '../errors.js'
@@ -55,9 +57,11 @@ export class Controller extends EventEmitter {
     this.#lastELU = performance.eventLoopUtilization()
 
     this.#context = {
+      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,
@@ -83,10 +87,7 @@ export class Controller extends EventEmitter {
     }
   }
 
-  async getBootstrapDependencies () {
-    return this.capability.getBootstrapDependencies?.() ?? []
-  }
-
+  // Note: capability's init() is executed within start
   async init () {
     try {
       const appConfig = this.appConfig
@@ -142,10 +143,17 @@ export class Controller extends EventEmitter {
 
     try {
       await this.capability.init?.()
+      this.emit('init')
     } catch (err) {
       this.#logAndThrow(err)
     }
 
+    this.emit('starting')
+
+    if (this.capability.status === 'stopped') {
+      return
+    }
+
     if (this.#watch) {
       const watchConfig = await this.capability.getWatchConfig()
 
@@ -174,21 +182,23 @@ export class Controller extends EventEmitter {
 
     this.#started = true
     this.#starting = false
-    this.emit('start')
+    this.emit('started')
   }
 
-  async stop (force = false) {
+  async stop (force = false, dependents = []) {
     if (!force && (!this.#started || this.#starting)) {
       throw new RuntimeNotStartedError()
     }
 
+    this.emit('stopping')
     await this.#stopFileWatching()
+    await this.capability.waitForDependentsStop(dependents)
     await this.capability.stop()
 
     this.#started = false
     this.#starting = false
     this.#listening = false
-    this.emit('stop')
+    this.emit('stopped')
   }
 
   async listen () {
@@ -213,6 +223,7 @@ export class Controller extends EventEmitter {
         globalThis.platformatic.onHttpStatsSize(url, size || 0)
       }
     }
+    globalThis.platformatic.onActiveResourcesEventLoop(getActiveResourcesInfo().length)
     return this.capability.getMetrics({ format })
   }
 
@@ -260,7 +271,11 @@ export class Controller extends EventEmitter {
   }
 
   #logAndThrow (err) {
-    globalThis.platformatic.logger.error({ err: ensureLoggableError(err) }, 'The application threw an error.')
+    globalThis.platformatic.logger.error(
+      { err: ensureLoggableError(err) },
+      err[kHandledError] ? err.message : 'The application threw an error.'
+    )
+
     throw err
   }
 

package/lib/worker/itc.js

@@ -69,8 +69,8 @@ export async function waitEventFromITC (worker, event) {
   return safeHandleInITC(worker, () => once(worker[kITC], event))
 }
 
-export function setupITC (instance, application, dispatcher, sharedContext) {
-  const messaging = new MessagingITC(instance.appConfig.id, workerData.config)
+export function setupITC (controller, application, dispatcher, sharedContext) {
+  const messaging = new MessagingITC(controller.appConfig.id, workerData.config)
 
   Object.assign(globalThis.platformatic ?? {}, {
     messaging: {
@@ -80,55 +80,61 @@ export function setupITC (instance, application, dispatcher, sharedContext) {
   })
 
   const itc = new ITC({
-    name: instance.appConfig.id + '-worker',
+    name: controller.appConfig.id + '-worker',
     port: parentPort,
     handlers: {
       async start () {
-        const status = instance.getStatus()
+        const status = controller.getStatus()
 
         if (status === 'starting') {
-          await once(instance, 'start')
+          await once(controller, 'start')
         } else {
           // This gives a chance to a capability to perform custom logic
           globalThis.platformatic.events.emit('start')
 
           try {
-            await instance.start()
+            await controller.start()
           } catch (e) {
-            await instance.stop(true)
-            await closeITC(dispatcher, itc, messaging)
+            await controller.stop(true)
+
+            // Reply to the runtime that the start failed, so it can cleanup
+            once(itc, 'application:worker:start:processed').then(() => {
+              closeITC(dispatcher, itc, messaging).catch(() => {})
+            })
 
             throw ensureLoggableError(e)
           }
         }
 
         if (application.entrypoint) {
-          await instance.listen()
+          await controller.listen()
         }
 
-        dispatcher.replaceServer(await instance.capability.getDispatchTarget())
-        return application.entrypoint ? instance.capability.getUrl() : null
+        dispatcher.replaceServer(await controller.capability.getDispatchTarget())
+        return application.entrypoint ? controller.capability.getUrl() : null
       },
 
-      async stop () {
-        const status = instance.getStatus()
+      async stop ({ force, dependents }) {
+        const status = controller.getStatus()
 
-        if (status === 'starting') {
-          await once(instance, 'start')
+        if (!force && status === 'starting') {
+          await once(controller, 'start')
         }
 
-        if (status.startsWith('start')) {
+        if (force || status.startsWith('start')) {
           // This gives a chance to a capability to perform custom logic
           globalThis.platformatic.events.emit('stop')
 
-          await instance.stop()
+          await controller.stop(force, dependents)
         }
 
-        await closeITC(dispatcher, itc, messaging)
+        once(itc, 'application:worker:stop:processed').then(() => {
+          closeITC(dispatcher, itc, messaging).catch(() => {})
+        })
       },
 
       async build () {
-        return instance.capability.build()
+        return controller.capability.build()
       },
 
       async removeFromMesh () {
@@ -136,7 +142,7 @@ export function setupITC (instance, application, dispatcher, sharedContext) {
       },
 
       inject (injectParams) {
-        return instance.capability.inject(injectParams)
+        return controller.capability.inject(injectParams)
       },
 
       async updateUndiciInterceptors (undiciConfig) {
@@ -150,27 +156,27 @@ export function setupITC (instance, application, dispatcher, sharedContext) {
       },
 
       getStatus () {
-        return instance.getStatus()
+        return controller.getStatus()
       },
 
       getApplicationInfo () {
-        return instance.capability.getInfo()
+        return controller.capability.getInfo()
       },
 
       async getApplicationConfig () {
-        const current = await instance.capability.getConfig()
+        const current = await controller.capability.getConfig()
         // Remove all undefined keys from the config
         return JSON.parse(JSON.stringify(current))
       },
 
       async getApplicationEnv () {
         // Remove all undefined keys from the config
-        return JSON.parse(JSON.stringify({ ...process.env, ...(await instance.capability.getEnv()) }))
+        return JSON.parse(JSON.stringify({ ...process.env, ...(await controller.capability.getEnv()) }))
       },
 
       async getApplicationOpenAPISchema () {
         try {
-          return await instance.capability.getOpenapiSchema()
+          return await controller.capability.getOpenapiSchema()
         } catch (err) {
           throw new FailedToRetrieveOpenAPISchemaError(application.id, err.message)
         }
@@ -178,7 +184,7 @@ export function setupITC (instance, application, dispatcher, sharedContext) {
 
       async getApplicationGraphQLSchema () {
         try {
-          return await instance.capability.getGraphqlSchema()
+          return await controller.capability.getGraphqlSchema()
         } catch (err) {
           throw new FailedToRetrieveGraphQLSchemaError(application.id, err.message)
         }
@@ -186,7 +192,7 @@ export function setupITC (instance, application, dispatcher, sharedContext) {
 
       async getApplicationMeta () {
         try {
-          return await instance.capability.getMeta()
+          return await controller.capability.getMeta()
         } catch (err) {
           throw new FailedToRetrieveMetaError(application.id, err.message)
         }
@@ -194,7 +200,7 @@ export function setupITC (instance, application, dispatcher, sharedContext) {
 
       async getMetrics (format) {
         try {
-          return await instance.getMetrics({ format })
+          return await controller.getMetrics({ format })
         } catch (err) {
           throw new FailedToRetrieveMetricsError(application.id, err.message)
         }
@@ -202,7 +208,7 @@ export function setupITC (instance, application, dispatcher, sharedContext) {
 
       async getHealth () {
         try {
-          return await instance.getHealth()
+          return await controller.getHealth()
         } catch (err) {
           throw new FailedToRetrieveHealthError(application.id, err.message)
         }
@@ -210,7 +216,7 @@ export function setupITC (instance, application, dispatcher, sharedContext) {
 
       async getCustomHealthCheck () {
         try {
-          return await instance.capability.getCustomHealthCheck()
+          return await controller.capability.getCustomHealthCheck()
         } catch (err) {
           throw new FailedToPerformCustomHealthCheckError(application.id, err.message)
         }
@@ -218,7 +224,7 @@ export function setupITC (instance, application, dispatcher, sharedContext) {
 
       async getCustomReadinessCheck () {
         try {
-          return await instance.capability.getCustomReadinessCheck()
+          return await controller.capability.getCustomReadinessCheck()
         } catch (err) {
           throw new FailedToPerformCustomReadinessCheckError(application.id, err.message)
         }
@@ -234,7 +240,7 @@ export function setupITC (instance, application, dispatcher, sharedContext) {
     }
   })
 
-  instance.on('changed', () => {
+  controller.on('changed', () => {
     itc.notify('changed')
   })
 

package/lib/worker/main.js

@@ -166,7 +166,7 @@ async function main () {
   }
 
   // Create the application
-  const app = new Controller(
+  const controller = new Controller(
     application,
     workerData.worker.count > 1 ? workerData.worker.index : undefined,
     application.telemetry,
@@ -177,13 +177,13 @@ async function main () {
     !!config.watch
   )
 
-  process.on('uncaughtException', handleUnhandled.bind(null, app, 'uncaught exception'))
-  process.on('unhandledRejection', handleUnhandled.bind(null, app, 'unhandled rejection'))
+  process.on('uncaughtException', handleUnhandled.bind(null, controller, 'uncaught exception'))
+  process.on('unhandledRejection', handleUnhandled.bind(null, controller, 'unhandled rejection'))
 
-  await app.init()
+  await controller.init()
 
   if (application.entrypoint && config.basePath) {
-    const meta = await app.capability.getMeta()
+    const meta = await controller.capability.getMeta()
     if (!meta.gateway.wantsAbsoluteUrls) {
       stripBasePath(config.basePath)
     }
@@ -197,12 +197,10 @@ async function main () {
   }
 
   // Setup interaction with parent port
-  const itc = setupITC(app, application, threadDispatcher, sharedContext)
+  const itc = setupITC(controller, application, threadDispatcher, sharedContext)
   globalThis[kITC] = itc
 
-  // Get the dependencies
-  const dependencies = await app.getBootstrapDependencies()
-  itc.notify('init', { dependencies })
+  itc.notify('init')
 }
 
 function stripBasePath (basePath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.0.0-alpha.6",
+  "version": "3.0.0-alpha.8",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -34,18 +34,19 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/gateway": "3.0.0-alpha.6",
-    "@platformatic/db": "3.0.0-alpha.6",
-    "@platformatic/node": "3.0.0-alpha.6",
-    "@platformatic/sql-mapper": "3.0.0-alpha.6",
-    "@platformatic/sql-graphql": "3.0.0-alpha.6",
-    "@platformatic/service": "3.0.0-alpha.6"
+    "@platformatic/composer": "3.0.0-alpha.8",
+    "@platformatic/gateway": "3.0.0-alpha.8",
+    "@platformatic/db": "3.0.0-alpha.8",
+    "@platformatic/node": "3.0.0-alpha.8",
+    "@platformatic/service": "3.0.0-alpha.8",
+    "@platformatic/sql-graphql": "3.0.0-alpha.8",
+    "@platformatic/sql-mapper": "3.0.0-alpha.8",
+    "@platformatic/wattpm-pprof-capture": "3.0.0-alpha.8"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
     "@fastify/error": "^4.0.0",
     "@fastify/websocket": "^11.0.0",
-    "@hapi/topo": "^6.0.2",
     "@opentelemetry/api": "^1.9.0",
     "@platformatic/undici-cache-memory": "^0.8.1",
     "@watchable/unpromise": "^1.0.2",
@@ -69,18 +70,18 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.14.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.0.0-alpha.6",
-    "@platformatic/itc": "3.0.0-alpha.6",
-    "@platformatic/foundation": "3.0.0-alpha.6",
-    "@platformatic/metrics": "3.0.0-alpha.6",
-    "@platformatic/generators": "3.0.0-alpha.6",
-    "@platformatic/telemetry": "3.0.0-alpha.6"
+    "@platformatic/basic": "3.0.0-alpha.8",
+    "@platformatic/generators": "3.0.0-alpha.8",
+    "@platformatic/itc": "3.0.0-alpha.8",
+    "@platformatic/telemetry": "3.0.0-alpha.8",
+    "@platformatic/metrics": "3.0.0-alpha.8",
+    "@platformatic/foundation": "3.0.0-alpha.8"
   },
   "engines": {
     "node": ">=22.18.0"
   },
   "scripts": {
-    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
+    "test": "npm run test:main && npm run test:api && npm run test:cli && npm run test:start && npm run test:multiple-workers",
     "test:main": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/versions/*.test.js",
     "test:api": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/api/*.test.js test/management-api/*.test.js",
     "test:cli": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/cli/*.test.js test/cli/**/*.test.js",
@@ -88,7 +89,7 @@
     "test:multiple-workers": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/multiple-workers/*.test.js",
     "gen-schema": "node lib/schema.js > schema.json",
     "gen-types": "json2ts > config.d.ts < schema.json",
-    "build": "pnpm run gen-schema && pnpm run gen-types",
+    "build": "npm run gen-schema && npm run gen-types",
     "lint": "eslint"
   }
 }

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.0.0-alpha.6.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.0.0-alpha.8.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -186,6 +186,12 @@
                   }
                 ]
               },
+              "dependencies": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
               "arguments": {
                 "type": "array",
                 "items": {
@@ -347,6 +353,13 @@
             },
             "additionalProperties": false
           },
+          "dependencies": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "default": []
+          },
           "arguments": {
             "type": "array",
             "items": {
@@ -576,6 +589,13 @@
             },
             "additionalProperties": false
           },
+          "dependencies": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "default": []
+          },
           "arguments": {
             "type": "array",
             "items": {
@@ -805,6 +825,13 @@
             },
             "additionalProperties": false
           },
+          "dependencies": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "default": []
+          },
           "arguments": {
             "type": "array",
             "items": {

package/lib/dependencies.js

@@ -1,63 +0,0 @@
-import { Sorter } from '@hapi/topo'
-import { closest } from 'fastest-levenshtein'
-import { MissingDependencyError } from './errors.js'
-import { RoundRobinMap } from './worker/round-robin-map.js'
-
-function missingDependencyErrorMessage (clientName, application, applications) {
-  const allNames = applications
-    .map(s => s.id)
-    .filter(id => id !== application.id)
-    .sort()
-  const closestName = closest(clientName, allNames)
-  let errorMsg = `application '${application.id}' has unknown dependency: '${clientName}'.`
-  if (closestName) {
-    errorMsg += ` Did you mean '${closestName}'?`
-  }
-  if (allNames.length) {
-    errorMsg += ` Known applications are: ${allNames.join(', ')}.`
-  }
-  return errorMsg
-}
-
-export function checkDependencies (applications) {
-  const allApplications = new Set(applications.map(s => s.id))
-
-  for (const application of applications) {
-    for (const dependency of application.dependencies) {
-      if (dependency.local && !allApplications.has(dependency.id)) {
-        throw new MissingDependencyError(missingDependencyErrorMessage(dependency.id, application, applications))
-      }
-    }
-  }
-}
-
-export function topologicalSort (workers, config) {
-  const topo = new Sorter()
-
-  for (const application of config.applications) {
-    const localDependencyIds = Array.from(application.dependencies)
-      .filter(dep => dep.local)
-      .map(dep => dep.id)
-
-    topo.add(application, {
-      group: application.id,
-      after: localDependencyIds,
-      manual: true
-    })
-  }
-
-  config.applications = topo.sort()
-
-  return new RoundRobinMap(
-    Array.from(workers.entries()).sort((a, b) => {
-      if (a[0] === b[0]) {
-        return 0
-      }
-
-      const aIndex = config.applications.findIndex(s => s.id === a[0])
-      const bIndex = config.applications.findIndex(s => s.id === b[0])
-      return aIndex - bIndex
-    }),
-    workers.configuration
-  )
-}