@platformatic/runtime 3.4.1 → 3.5.1

package/lib/runtime.js

@@ -1,144 +1,271 @@
-'use strict'
-
-const { once, EventEmitter } = require('node:events')
-const { createReadStream, watch } = require('node:fs')
-const { readdir, readFile, stat, access } = require('node:fs/promises')
-const inspector = require('node:inspector')
-const { join } = require('node:path')
-const { setTimeout: sleep } = require('node:timers/promises')
-const { Worker } = require('node:worker_threads')
-const { ITC } = require('@platformatic/itc')
-const { ensureLoggableError, executeWithTimeout } = require('@platformatic/utils')
-const ts = require('tail-file-stream')
-const { createThreadInterceptor } = require('undici-thread-interceptor')
-
-const { checkDependencies, topologicalSort } = require('./dependencies')
-const errors = require('./errors')
-const { createLogger } = require('./logger')
-const { startManagementApi } = require('./management-api')
-const { startPrometheusServer } = require('./prom-server')
-const { getRuntimeTmpDir } = require('./utils')
-const { sendViaITC, waitEventFromITC } = require('./worker/itc')
-const { kId, kITC, kConfig } = require('./worker/symbols')
-
-const platformaticVersion = require('../package.json').version
-const kWorkerFile = join(__dirname, 'worker/main.js')
+import {
+  deepmerge,
+  ensureError,
+  ensureLoggableError,
+  executeInParallel,
+  executeWithTimeout,
+  features,
+  kMetadata,
+  kTimeout,
+  parseMemorySize
+} from '@platformatic/foundation'
+import { ITC } from '@platformatic/itc'
+import fastify from 'fastify'
+import { EventEmitter, once } from 'node:events'
+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 { 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 {
+  ApplicationAlreadyStartedError,
+  ApplicationNotFoundError,
+  ApplicationNotStartedError,
+  ApplicationStartTimeoutError,
+  InvalidArgumentError,
+  MessagingError,
+  MissingEntrypointError,
+  MissingPprofCapture,
+  RuntimeAbortedError,
+  RuntimeExitedError,
+  WorkerNotFoundError
+} from './errors.js'
+import { abstractLogger, createLogger } from './logger.js'
+import { startManagementApi } from './management-api.js'
+import { startPrometheusServer } from './prom-server.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 {
+  kApplicationId,
+  kConfig,
+  kFullId,
+  kHealthCheckTimer,
+  kId,
+  kITC,
+  kLastELU,
+  kStderrMarker,
+  kWorkerId,
+  kWorkersBroadcast,
+  kWorkerStatus
+} from './worker/symbols.js'
+
+const kWorkerFile = join(import.meta.dirname, 'worker/main.js')
+const kInspectorOptions = Symbol('plt.runtime.worker.inspectorOptions')
 
 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
 
-class Runtime extends EventEmitter {
-  #configManager
-  #runtimeTmpDir
-  #runtimeLogsDir
+export class Runtime extends EventEmitter {
+  logger
+  error
+
+  #loggerDestination
+  #stdio
+
+  #status // starting, started, stopping, stopped, closed
+  #root
+  #config
   #env
-  #services
-  #servicesIds
-  #entrypoint
+  #context
+  #sharedContext
+  #isProduction
+  #concurrency
   #entrypointId
   #url
-  #loggerDestination
+
   #metrics
   #metricsTimeout
-  #status
-  #interceptor
+
+  #meshInterceptor
+  #dispatcher
+
   #managementApi
   #prometheusServer
-  #startedServices
-  #restartPromises
-  #bootstrapAttempts
+  #inspectorServer
+  #metricsLabelName
+
+  #applicationsConfigsPatches
+  #workers
+  #workersBroadcastChannel
+  #workerITCHandlers
+  #restartingWorkers
 
-  constructor (configManager, runtimeLogsDir, env) {
+  #sharedHttpCache
+  #scheduler
+
+  constructor (config, context) {
     super()
     this.setMaxListeners(MAX_LISTENERS_COUNT)
 
-    this.#configManager = configManager
-    this.#runtimeTmpDir = getRuntimeTmpDir(configManager.dirname)
-    this.#runtimeLogsDir = runtimeLogsDir
-    this.#env = env
-    this.#services = new Map()
-    this.#servicesIds = []
+    this.#config = config
+    this.#root = config[kMetadata].root
+    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
-    // Note: nothing hits the main thread so there is no reason to set the globalDispatcher here
-    this.#interceptor = createThreadInterceptor({ domain: '.plt.local', timeout: true })
+    this.#meshInterceptor = createThreadInterceptor({ domain: '.plt.local', timeout: this.#config.applicationTimeout })
+    this.logger = abstractLogger // This is replaced by the real logger in init() and eventually removed in close()
     this.#status = undefined
-    this.#startedServices = new Map()
-    this.#restartPromises = new Map()
-    this.#bootstrapAttempts = new Map()
+    this.#restartingWorkers = new Map()
+    this.#sharedHttpCache = null
+    this.#applicationsConfigsPatches = new Map()
+
+    if (!this.#config.logger.captureStdio) {
+      this.#stdio = {
+        stdout: new SonicBoom({ fd: process.stdout.fd }),
+        stderr: new SonicBoom({ fd: process.stderr.fd })
+      }
+    }
+
+    this.#workerITCHandlers = {
+      getApplicationMeta: this.getApplicationMeta.bind(this),
+      listApplications: this.getApplicationsIds.bind(this),
+      getApplications: this.getApplications.bind(this),
+      getWorkers: this.getWorkers.bind(this),
+      getWorkerMessagingChannel: this.#getWorkerMessagingChannel.bind(this),
+      getHttpCacheValue: this.#getHttpCacheValue.bind(this),
+      setHttpCacheValue: this.#setHttpCacheValue.bind(this),
+      deleteHttpCacheValue: this.#deleteHttpCacheValue.bind(this),
+      invalidateHttpCache: this.invalidateHttpCache.bind(this),
+      updateSharedContext: this.updateSharedContext.bind(this),
+      getSharedContext: this.getSharedContext.bind(this)
+    }
+    this.#sharedContext = {}
   }
 
   async init () {
-    const config = this.#configManager.current
-    const autoloadEnabled = config.autoload
+    if (typeof this.#status !== 'undefined') {
+      return
+    }
 
-    // This cannot be transferred to worker threads
-    delete config.configManager
+    const config = this.#config
 
     if (config.managementApi) {
-      this.#managementApi = await startManagementApi(this, this.#configManager)
+      this.#managementApi = await startManagementApi(this, this.#root)
     }
 
     if (config.metrics) {
+      // Use the configured application label name for metrics (defaults to 'applicationId')
+      this.#metricsLabelName = config.metrics.applicationLabel || 'applicationId'
       this.#prometheusServer = await startPrometheusServer(this, config.metrics)
+    } else {
+      // Default to applicationId if metrics are not configured
+      this.#metricsLabelName = 'applicationId'
     }
 
     // Create the logger
-    const [logger, destination] = createLogger(config, this.#runtimeLogsDir)
+    const [logger, destination] = await createLogger(config)
     this.logger = logger
     this.#loggerDestination = destination
 
-    // Handle inspector
-    const inspectorOptions = config.inspectorOptions
-    if (inspectorOptions) {
-      /* c8 ignore next 6 */
-      if (inspectorOptions.watchDisabled) {
-        logger.info('debugging flags were detected. hot reloading has been disabled')
-      }
+    this.#createWorkersBroadcastChannel()
 
-      inspector.open(inspectorOptions.port, inspectorOptions.host, inspectorOptions.breakFirstLine)
+    const workersConfig = []
+    for (const application of config.applications) {
+      const count = application.workers ?? this.#config.workers
+      if (count > 1 && application.entrypoint && !features.node.reusePort) {
+        this.logger.warn(
+          `"${application.id}" is set as the entrypoint, but reusePort is not available in your OS; setting workers to 1 instead of ${count}`
+        )
+        workersConfig.push({ id: application.id, workers: 1 })
+      } else {
+        workersConfig.push({ id: application.id, workers: count })
+      }
     }
 
-    // Create all services, each in is own worker thread
-    for (const serviceConfig of config.services) {
-      // Setup forwarding of logs from the worker threads to the main thread
-      await this.#setupService(serviceConfig)
+    this.#workers.configure(workersConfig)
+
+    if (this.#isProduction) {
+      this.#env['PLT_DEV'] = 'false'
+      this.#env['PLT_ENVIRONMENT'] = 'production'
+    } else {
+      this.#env['PLT_DEV'] = 'true'
+      this.#env['PLT_ENVIRONMENT'] = 'development'
     }
 
-    try {
-      // Make sure the list exists before computing the dependencies, otherwise some services might not be stopped
-      this.#servicesIds = config.services.map(service => service.id)
+    await this.#setupApplications()
 
-      if (autoloadEnabled) {
-        checkDependencies(config.services)
-        this.#services = topologicalSort(this.#services, config)
-      }
+    await this.#setDispatcher(config.undici)
 
-      // Recompute the list of services after sorting
-      this.#servicesIds = config.services.map(service => service.id)
-    } catch (e) {
-      await this.close()
-      throw e
+    if (config.scheduler) {
+      this.#scheduler = startScheduler(config.scheduler, this.#dispatcher, logger)
     }
 
     this.#updateStatus('init')
   }
 
-  async start () {
+  async start (silent = false) {
+    if (typeof this.#status === 'undefined') {
+      await this.init()
+    }
+
+    if (typeof this.#config.entrypoint === 'undefined') {
+      throw new MissingEntrypointError()
+    }
     this.#updateStatus('starting')
+    this.#createWorkersBroadcastChannel()
 
-    // Important: do not use Promise.all here since it won't properly manage dependencies
     try {
-      for (const service of this.#servicesIds) {
-        await this.startService(service)
+      const startInvocations = []
+      for (const application of this.getApplicationsIds()) {
+        startInvocations.push([application, silent])
+      }
+
+      await executeInParallel(this.startApplication.bind(this), startInvocations, this.#concurrency)
+
+      if (this.#config.inspectorOptions) {
+        const { port } = this.#config.inspectorOptions
+
+        const server = fastify({
+          loggerInstance: this.logger.child({ name: 'inspector' }, { level: 'warn' })
+        })
+
+        const version = await fetch(`http://127.0.0.1:${this.#config.inspectorOptions.port + 1}/json/version`).then(
+          res => res.json()
+        )
+
+        const data = await Promise.all(
+          Array.from(this.#workers.values()).map(async worker => {
+            const data = worker[kInspectorOptions]
+
+            const res = await fetch(`http://127.0.0.1:${data.port}/json/list`)
+            const details = await res.json()
+            return {
+              ...details[0],
+              title: data.id
+            }
+          })
+        )
+
+        server.get('/json/list', () => data)
+        server.get('/json', () => data)
+        server.get('/json/version', () => version)
+
+        await server.listen({ port })
+        this.logger.info(
+          'The inspector server is now listening for all applications. Open `chrome://inspect` in Google Chrome to connect.'
+        )
+        this.#inspectorServer = server
       }
     } catch (error) {
-      // Wait for the next tick so that the error is logged first
-      await sleep(1)
-      await this.close()
-      throw error
+      await this.closeAndThrow(error)
     }
 
     this.#updateStatus('started')
@@ -152,14 +279,60 @@ class Runtime extends EventEmitter {
   }
 
   async stop (silent = false) {
+    if (this.#scheduler) {
+      await this.#scheduler.stop()
+    }
+
     if (this.#status === 'starting') {
       await once(this, 'started')
     }
 
     this.#updateStatus('stopping')
-    this.#startedServices.clear()
 
-    await Promise.all(this.#servicesIds.map(service => this._stopService(service, silent)))
+    if (this.#inspectorServer) {
+      await this.#inspectorServer.close()
+    }
+
+    // Stop the entrypoint first so that no new requests are accepted
+    if (this.#entrypointId) {
+      await this.stopApplication(this.#entrypointId, silent)
+    }
+
+    const stopInvocations = []
+
+    // Construct the reverse dependency graph
+    const dependents = {}
+
+    try {
+      const allApplications = await this.getApplications(true)
+      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)
+        }
+      }
+    } catch (e) {
+      // Noop - This only happens if stop is invoked after a failed start, in which case we don't care about deps
+    }
+
+    for (const application of this.getApplicationsIds()) {
+      // The entrypoint has been stopped above
+      if (application === this.#entrypointId) {
+        continue
+      }
+
+      stopInvocations.push([application, silent, Array.from(dependents[application] ?? [])])
+    }
+
+    await executeInParallel(this.stopApplication.bind(this), stopInvocations, this.#concurrency)
+
+    await this.#meshInterceptor.close()
+    this.#workersBroadcastChannel?.close()
 
     this.#updateStatus('stopped')
   }
@@ -168,6 +341,7 @@ class Runtime extends EventEmitter {
     this.emit('restarting')
 
     await this.stop()
+    this.#meshInterceptor.restart()
     await this.start()
 
     this.emit('restarted')
@@ -175,139 +349,172 @@ class Runtime extends EventEmitter {
     return this.#url
   }
 
-  async close (fromManagementApi = false, silent = false) {
-    this.#updateStatus('closing')
-
+  async close (silent = false) {
     clearInterval(this.#metricsTimeout)
 
     await this.stop(silent)
+    this.#updateStatus('closing')
 
-    if (this.#managementApi) {
-      if (fromManagementApi) {
-        // This allow a close request coming from the management API to correctly be handled
-        setImmediate(() => {
-          this.#managementApi.close()
-        })
-      } else {
-        await this.#managementApi.close()
-      }
-    }
+    // The management API autocloses by itself via event in management-api.js.
+    // This is needed to let management API stop endpoint to reply.
 
     if (this.#prometheusServer) {
       await this.#prometheusServer.close()
     }
 
     if (this.logger) {
-      this.#loggerDestination.end()
+      this.#loggerDestination?.end()
 
-      this.logger = null
+      this.logger = abstractLogger
       this.#loggerDestination = null
     }
 
+    if (this.#sharedHttpCache?.close) {
+      await this.#sharedHttpCache.close()
+    }
+
     this.#updateStatus('closed')
   }
 
-  async startService (id) {
-    if (this.#startedServices.get(id)) {
-      throw new errors.ApplicationAlreadyStartedError()
-    }
+  async closeAndThrow (error) {
+    this.#updateStatus('errored', error)
+    this.error = error
 
-    // This is set here so that if the service fails while starting we track the status
-    this.#startedServices.set(id, true)
+    // Wait for the next tick so that any pending logging is properly flushed
+    await sleep(1)
+    await this.close()
 
-    let service = await this.#getServiceById(id, false, false)
+    throw error
+  }
 
-    // The service was stopped, recreate the thread
-    if (!service) {
-      const config = this.#configManager.current
-      const serviceConfig = config.services.find(s => s.id === id)
+  async inject (id, injectParams) {
+    // Make sure the application exists
+    await this.#getApplicationById(id, true)
 
-      await this.#setupService(serviceConfig)
-      service = await this.#getServiceById(id)
+    if (typeof injectParams === 'string') {
+      injectParams = { url: injectParams }
     }
 
-    try {
-      const serviceUrl = await sendViaITC(service, 'start')
-      if (serviceUrl) {
-        this.#url = serviceUrl
+    let { method, headers, body } = injectParams
+    const url = new URL(injectParams.url, `http://${id}.plt.local`)
+
+    if (injectParams.query) {
+      for (const [k, v] of Object.entries(injectParams.query)) {
+        url.searchParams.append(k, v)
       }
-      this.#bootstrapAttempts.set(id, 0)
-    } catch (error) {
-      // TODO: handle port allocation error here
-      if (error.code === 'EADDRINUSE') throw error
+    }
 
-      this.logger.error({ err: ensureLoggableError(error) }, `Failed to start service "${id}".`)
+    // Stringify the body as JSON if needed
+    if (
+      body &&
+      typeof body === 'object' &&
+      headers &&
+      Object.entries(headers).some(([k, v]) => k.toLowerCase() === 'content-type' && v.includes('application/json'))
+    ) {
+      body = JSON.stringify(body)
+    }
 
-      const config = this.#configManager.current
-      const restartOnError = config.restartOnError
+    const {
+      statusCode: responseStatus,
+      headers: responseHeaders,
+      body: responseRawBody
+    } = await request(url.toString(), { method, headers, body, dispatcher: this.#dispatcher })
+    const responsePayload = await responseRawBody.arrayBuffer()
+    const responseBody = Buffer.from(responsePayload).toString('utf-8')
 
-      if (!restartOnError) {
-        this.logger.error(`Failed to start service "${id}".`)
-        throw error
-      }
+    return {
+      statusCode: responseStatus,
+      statusMessage: STATUS_CODES[responseStatus] || 'unknown',
+      headers: responseHeaders,
+      body: responseBody,
+      payload: responseBody,
+      rawPayload: responsePayload
+    }
+  }
 
-      let bootstrapAttempt = this.#bootstrapAttempts.get(id)
-      if (bootstrapAttempt++ >= MAX_BOOTSTRAP_ATTEMPTS || restartOnError === 0) {
-        this.logger.error(`Failed to start service "${id}" after ${MAX_BOOTSTRAP_ATTEMPTS} attempts.`)
-        throw error
-      }
+  emit (event, payload) {
+    for (const worker of this.#workers.values()) {
+      worker[kITC].notify('runtime:event', { event, payload })
+    }
 
-      this.logger.warn(
-        `Starting a service "${id}" in ${restartOnError}ms. ` +
-          `Attempt ${bootstrapAttempt} of ${MAX_BOOTSTRAP_ATTEMPTS}...`
-      )
+    this.logger.trace({ event, payload }, 'Runtime event')
+    return super.emit(event, payload)
+  }
+
+  async sendCommandToApplication (id, name, message) {
+    const application = await this.#getApplicationById(id)
+
+    try {
+      return await sendViaITC(application, name, message)
+    } catch (e) {
+      // The application exports no meta, return an empty object
+      if (e.code === 'PLT_ITC_HANDLER_NOT_FOUND') {
+        return {}
+      }
 
-      this.#bootstrapAttempts.set(id, bootstrapAttempt)
-      await this.#restartCrashedService(id)
+      throw e
     }
   }
 
-  // Do not rename to #stopService as this is used in tests
-  async _stopService (id, silent) {
-    const service = await this.#getServiceById(id, false, false)
-
-    if (!service) {
-      return
+  async startApplication (id, silent = false) {
+    // Since when an application is stopped the worker is deleted, we consider an application start if its first application
+    // is no longer in the init phase
+    const firstWorker = this.#workers.get(`${id}:0`)
+    if (firstWorker && firstWorker[kWorkerStatus] !== 'boot' && firstWorker[kWorkerStatus] !== 'init') {
+      throw new ApplicationAlreadyStartedError()
     }
 
-    this.#startedServices.set(id, false)
+    const config = this.#config
+    const applicationConfig = config.applications.find(s => s.id === id)
 
-    if (!silent) {
-      this.logger?.info(`Stopping service "${id}"...`)
+    if (!applicationConfig) {
+      throw new ApplicationNotFoundError(id, this.getApplicationsIds().join(', '))
     }
 
-    // Always send the stop message, it will shut down workers that only had ITC and interceptors setup
-    try {
-      await executeWithTimeout(sendViaITC(service, 'stop'), 10000)
-    } catch (error) {
-      this.logger?.info(
-        { error: ensureLoggableError(error) },
-        `Failed to stop service "${id}". Killing a worker thread.`
-      )
-    } finally {
-      service[kITC].close()
-    }
+    const workersCount = await this.#workers.getCount(applicationConfig.id)
 
-    // Wait for the worker thread to finish, we're going to create a new one if the service is ever restarted
-    const res = await executeWithTimeout(once(service, 'exit'), 10000)
+    this.emit('application:starting', id)
 
-    // If the worker didn't exit in time, kill it
-    if (res === 'timeout') {
-      await service.terminate()
+    for (let i = 0; i < workersCount; i++) {
+      await this.#startWorker(config, applicationConfig, workersCount, id, i, silent)
     }
+
+    this.emit('application:started', id)
   }
 
-  async buildService (id) {
-    const service = this.#services.get(id)
+  async stopApplication (id, silent = false, dependents = []) {
+    const config = this.#config
+    const applicationConfig = config.applications.find(s => s.id === id)
 
-    if (!service) {
-      throw new errors.ServiceNotFoundError(id, Array.from(this.#services.keys()).join(', '))
+    if (!applicationConfig) {
+      throw new ApplicationNotFoundError(id, this.getApplicationsIds().join(', '))
     }
 
+    const workersCount = await this.#workers.getCount(applicationConfig.id)
+
+    this.emit('application:stopping', id)
+
+    if (typeof workersCount === 'number') {
+      const stopInvocations = []
+      for (let i = 0; i < workersCount; i++) {
+        stopInvocations.push([workersCount, id, i, silent, undefined, dependents])
+      }
+
+      await executeInParallel(this.#stopWorker.bind(this), stopInvocations, this.#concurrency)
+    }
+
+    this.emit('application:stopped', id)
+  }
+
+  async buildApplication (id) {
+    const application = await this.#getApplicationById(id)
+
+    this.emit('application:building', id)
     try {
-      return await sendViaITC(service, 'build')
+      await sendViaITC(application, 'build')
+      this.emit('application:built', id)
     } catch (e) {
-      // The service exports no meta, return an empty object
+      // The application exports no meta, return an empty object
       if (e.code === 'PLT_ITC_HANDLER_NOT_FOUND') {
         return {}
       }
@@ -316,9 +523,34 @@ class Runtime extends EventEmitter {
     }
   }
 
-  async inject (id, injectParams) {
-    const service = await this.#getServiceById(id, true)
-    return sendViaITC(service, 'inject', injectParams)
+  async startApplicationProfiling (id, options = {}, ensureStarted = true) {
+    const service = await this.#getApplicationById(id, ensureStarted)
+    this.#validatePprofCapturePreload()
+
+    return sendViaITC(service, 'startProfiling', options)
+  }
+
+  async stopApplicationProfiling (id, ensureStarted = true) {
+    const service = await this.#getApplicationById(id, ensureStarted)
+    this.#validatePprofCapturePreload()
+
+    return sendViaITC(service, 'stopProfiling')
+  }
+
+  async updateUndiciInterceptors (undiciConfig) {
+    this.#config.undici = undiciConfig
+
+    const promises = []
+    for (const worker of this.#workers.values()) {
+      promises.push(sendViaITC(worker, 'updateUndiciInterceptors', undiciConfig))
+    }
+
+    const results = await Promise.allSettled(promises)
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        throw result.reason
+      }
+    }
   }
 
   startCollectingMetrics () {
@@ -332,9 +564,8 @@ class Runtime extends EventEmitter {
       try {
         metrics = await this.getFormattedMetrics()
       } catch (error) {
-        if (!(error instanceof errors.RuntimeExitedError)) {
-          // TODO(mcollina): use the logger
-          console.error('Error collecting metrics', error)
+        if (!(error instanceof RuntimeExitedError)) {
+          this.logger.error({ err: ensureLoggableError(error) }, 'Error collecting metrics')
         }
         return
       }
@@ -347,91 +578,189 @@ class Runtime extends EventEmitter {
     }, COLLECT_METRICS_TIMEOUT).unref()
   }
 
-  async pipeLogsStream (writableStream, logger, startLogId, endLogId, runtimePID) {
-    endLogId = endLogId || Infinity
-    runtimePID = runtimePID ?? process.pid
+  invalidateHttpCache (options = {}) {
+    const { keys, tags } = options
 
-    const runtimeLogFiles = await this.#getRuntimeLogFiles(runtimePID)
-    if (runtimeLogFiles.length === 0) {
-      writableStream.end()
+    if (!this.#sharedHttpCache) {
       return
     }
 
-    let latestFileId = parseInt(runtimeLogFiles.at(-1).slice('logs.'.length))
+    const promises = []
+    if (keys && keys.length > 0) {
+      promises.push(this.#sharedHttpCache.deleteKeys(keys))
+    }
+
+    if (tags && tags.length > 0) {
+      promises.push(this.#sharedHttpCache.deleteTags(tags))
+    }
+
+    return Promise.all(promises)
+  }
 
-    let fileStream = null
-    let fileId = startLogId ?? latestFileId
-    let isClosed = false
+  async addLoggerDestination (writableStream) {
+    // Add the stream - We output everything we get
+    this.#loggerDestination.add({ stream: writableStream, level: 1 })
 
-    const runtimeLogsDir = this.#getRuntimeLogsDir(runtimePID)
+    // Immediately get the counter of the lastId so we can use it to later remove it
+    const id = this.#loggerDestination.lastId
 
-    const watcher = watch(runtimeLogsDir, async (event, filename) => {
-      if (event === 'rename' && filename.startsWith('logs')) {
-        const logFileId = parseInt(filename.slice('logs.'.length))
-        if (logFileId > latestFileId) {
-          latestFileId = logFileId
-          fileStream.unwatch()
-        }
-      }
-    }).unref()
+    const onClose = () => {
+      writableStream.removeListener('close', onClose)
+      writableStream.removeListener('error', onClose)
+      this.removeListener('closed', onClose)
+      this.#loggerDestination.remove(id)
+    }
 
-    const streamLogFile = () => {
-      if (fileId > endLogId) {
-        writableStream.end()
-        return
-      }
+    writableStream.on('close', onClose)
+    writableStream.on('error', onClose)
+    this.on('closed', onClose)
+  }
 
-      const fileName = 'logs.' + fileId
-      const filePath = join(runtimeLogsDir, fileName)
+  async updateSharedContext (options = {}) {
+    const { context, overwrite = false } = options
 
-      const prevFileStream = fileStream
+    const sharedContext = overwrite ? {} : this.#sharedContext
+    Object.assign(sharedContext, context)
 
-      fileStream = ts.createReadStream(filePath)
-      fileStream.pipe(writableStream, { end: false, persistent: false })
+    this.#sharedContext = sharedContext
 
-      if (prevFileStream) {
-        prevFileStream.unpipe(writableStream)
-        prevFileStream.destroy()
+    const promises = []
+    for (const worker of this.#workers.values()) {
+      promises.push(sendViaITC(worker, 'setSharedContext', sharedContext))
+    }
+
+    const results = await Promise.allSettled(promises)
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        this.logger.error({ err: result.reason }, 'Cannot update shared context')
       }
+    }
 
-      fileStream.on('close', () => {
-        if (latestFileId > fileId && !isClosed) {
-          streamLogFile(++fileId)
-        }
-      })
+    return sharedContext
+  }
 
-      fileStream.on('error', err => {
-        isClosed = true
-        logger.error(err, 'Error streaming log file')
-        fileStream.destroy()
-        watcher.close()
-        writableStream.end()
-      })
+  setApplicationConfigPatch (id, patch) {
+    this.#applicationsConfigsPatches.set(id, patch)
+  }
 
-      fileStream.on('eof', () => {
-        if (fileId >= endLogId) {
-          writableStream.end()
-          return
-        }
-        if (latestFileId > fileId) {
-          fileStream.unwatch()
-        }
-      })
+  removeApplicationConfigPatch (id) {
+    this.#applicationsConfigsPatches.delete(id)
+  }
 
-      return fileStream
+  /**
+   * Updates the resources of the applications, such as the number of workers and health configurations (e.g., heap memory settings).
+   *
+   * This function handles three update scenarios for each application:
+   *  1. **Updating workers only**: Adjusts the number of workers for the application.
+   *  2. **Updating health configurations only**: Updates health parameters like `maxHeapTotal` or `maxYoungGeneration`.
+   *  3. **Updating both workers and health configurations**: Scales the workers and also applies health settings.
+   *
+   * When updating both workers and health:
+   *  - **Scaling down workers**: Stops extra workers, then restarts the remaining workers with the previous settings.
+   *  - **Scaling up workers**: Starts new workers with the updated heap settings, then restarts the old workers with the updated settings.
+   *
+   * Scaling up new resources (workers and/or heap memory) may fails due to insufficient memory, in this case the operation may fail partially or entirely.
+   * Scaling down is expected to succeed without issues.
+   *
+   * @param {Array<Object>} updates - An array of objects that define the updates for each application.
+   * @param {string} updates[].application - The ID of the application to update.
+   * @param {number} [updates[].workers] - The desired number of workers for the application. If omitted, workers will not be updated.
+   * @param {Object} [updates[].health] - The health configuration to update for the application, which may include:
+   *   @param {string|number} [updates[].health.maxHeapTotal] - The maximum heap memory for the application. Can be a valid memory string (e.g., '1G', '512MB') or a number representing bytes.
+   *   @param {string|number} [updates[].health.maxYoungGeneration] - The maximum young generation memory for the application. Can be a valid memory string (e.g., '128MB') or a number representing bytes.
+   *
+   * @returns {Promise<Array<Object>>} - A promise that resolves to an array of reports for each application, detailing the success or failure of the operations:
+   *   - `application`: The application ID.
+   *   - `workers`: The workers' update report, including the current, new number of workers, started workers, and success status.
+   *   - `health`: The health update report, showing the current and new heap settings, updated workers, and success status.
+   *
+   * @example
+   * await runtime.updateApplicationsResources([
+   *   { application: 'application-1', workers: 2, health: { maxHeapTotal: '1G', maxYoungGeneration: '128 MB' } },
+   *   { application: 'application-2', health: { maxHeapTotal: '1G' } },
+   *   { application: 'application-3', workers: 2 },
+   * ])
+   *
+   * In this example:
+   * - `application-1` will have 2 workers and updated heap memory configurations.
+   * - `application-2` will have updated heap memory settings (without changing workers).
+   * - `application-3` will have its workers set to 2 but no change in memory settings.
+   *
+   * @throws {InvalidArgumentError} - Throws if any update parameter is invalid, such as:
+   *   - Missing application ID.
+   *   - Invalid worker count (not a positive integer).
+   *   - Invalid memory size format for `maxHeapTotal` or `maxYoungGeneration`.
+   * @throws {ApplicationNotFoundError} - Throws if the specified application ID does not exist in the current application configuration.
+   */
+  async updateApplicationsResources (updates) {
+    if (this.#status === 'stopping' || this.#status === 'closed') {
+      this.logger.warn('Cannot update application resources when the runtime is stopping or closed')
+      return
     }
 
-    streamLogFile(fileId)
-
-    const onClose = () => {
-      isClosed = true
-      watcher.close()
-      fileStream.destroy()
+    const ups = await this.#validateUpdateApplicationResources(updates)
+    const config = this.#config
+
+    const report = []
+    for (const update of ups) {
+      const { applicationId, config: applicationConfig, workers, health, currentWorkers, currentHealth } = update
+
+      if (workers && health) {
+        const r = await this.#updateApplicationWorkersAndHealth(
+          applicationId,
+          config,
+          applicationConfig,
+          workers,
+          health,
+          currentWorkers,
+          currentHealth
+        )
+        report.push({
+          application: applicationId,
+          workers: r.workers,
+          health: r.health
+        })
+      } else if (health) {
+        const r = await this.#updateApplicationHealth(
+          applicationId,
+          config,
+          applicationConfig,
+          currentWorkers,
+          currentHealth,
+          health
+        )
+        report.push({
+          application: applicationId,
+          health: r.health
+        })
+      } else if (workers) {
+        const r = await this.#updateApplicationWorkers(
+          applicationId,
+          config,
+          applicationConfig,
+          workers,
+          currentWorkers
+        )
+        report.push({
+          application: applicationId,
+          workers: r.workers
+        })
+      }
     }
 
-    writableStream.on('close', onClose)
-    writableStream.on('error', onClose)
-    this.on('closed', onClose)
+    return report
+  }
+
+  setConcurrency (concurrency) {
+    this.#concurrency = concurrency
+  }
+
+  async getUrl () {
+    return this.#url
+  }
+
+  getRuntimeStatus () {
+    return this.#status
   }
 
   async getRuntimeMetadata () {
@@ -445,24 +774,33 @@ class Runtime extends EventEmitter {
       uptimeSeconds: Math.floor(process.uptime()),
       execPath: process.execPath,
       nodeVersion: process.version,
-      projectDir: this.#configManager.dirname,
+      projectDir: this.#root,
       packageName: packageJson.name ?? null,
       packageVersion: packageJson.version ?? null,
       url: entrypointDetails?.url ?? null,
-      platformaticVersion
+      platformaticVersion: version
     }
   }
 
   getRuntimeEnv () {
-    return this.#configManager.env
+    return this.#env
   }
 
-  getRuntimeConfig () {
-    return this.#configManager.current
+  getRuntimeConfig (includeMeta = false) {
+    if (includeMeta) {
+      return this.#config
+    }
+
+    const { [kMetadata]: _, ...config } = this.#config
+    return config
   }
 
   getInterceptor () {
-    return this.#interceptor
+    return this.#meshInterceptor
+  }
+
+  getDispatcher () {
+    return this.#dispatcher
   }
 
   getManagementApi () {
@@ -470,110 +808,76 @@ class Runtime extends EventEmitter {
   }
 
   getManagementApiUrl () {
-    return this.#managementApi?.server.address()
+    return this.#managementApi?.server.address() ?? null
   }
 
   async getEntrypointDetails () {
-    return this.getServiceDetails(this.#entrypointId)
+    return this.getApplicationDetails(this.#entrypointId)
   }
 
-  async getServices () {
-    return {
-      entrypoint: this.#entrypointId,
-      services: await Promise.all(this.#servicesIds.map(id => this.getServiceDetails(id)))
-    }
-  }
+  async getCustomHealthChecks () {
+    const status = {}
 
-  async getServiceDetails (id, allowUnloaded = false) {
-    let service
+    for (const [application, { count }] of Object.entries(this.#workers.configuration)) {
+      for (let i = 0; i < count; i++) {
+        const label = `${application}:${i}`
+        const worker = this.#workers.get(label)
 
-    try {
-      service = await this.#getServiceById(id)
-    } catch (e) {
-      if (allowUnloaded) {
-        return { id, status: 'stopped' }
+        if (worker) {
+          status[label] = await sendViaITC(worker, 'getCustomHealthCheck')
+        }
       }
-
-      throw e
-    }
-
-    const { entrypoint, dependencies, localUrl } = service[kConfig]
-
-    const status = await sendViaITC(service, 'getStatus')
-    const { type, version } = await sendViaITC(service, 'getServiceInfo')
-
-    const serviceDetails = {
-      id,
-      type,
-      status,
-      version,
-      localUrl,
-      entrypoint,
-      dependencies
-    }
-
-    if (entrypoint) {
-      serviceDetails.url = status === 'started' ? this.#url : null
     }
 
-    return serviceDetails
+    return status
   }
 
-  async getService (id) {
-    return this.#getServiceById(id, true)
-  }
-
-  async getServiceConfig (id) {
-    const service = await this.#getServiceById(id, true)
-
-    return sendViaITC(service, 'getServiceConfig')
-  }
-
-  async getServiceEnv (id) {
-    const service = await this.#getServiceById(id, true)
-
-    return sendViaITC(service, 'getServiceEnv')
-  }
-
-  async getServiceOpenapiSchema (id) {
-    const service = await this.#getServiceById(id, true)
+  async getCustomReadinessChecks () {
+    const status = {}
 
-    return sendViaITC(service, 'getServiceOpenAPISchema')
-  }
+    for (const [application, { count }] of Object.entries(this.#workers.configuration)) {
+      for (let i = 0; i < count; i++) {
+        const label = `${application}:${i}`
+        const worker = this.#workers.get(label)
 
-  async getServiceGraphqlSchema (id) {
-    const service = await this.#getServiceById(id, true)
+        if (worker) {
+          status[label] = await sendViaITC(worker, 'getCustomReadinessCheck')
+        }
+      }
+    }
 
-    return sendViaITC(service, 'getServiceGraphQLSchema')
+    return status
   }
 
   async getMetrics (format = 'json') {
     let metrics = null
 
-    for (const id of this.#servicesIds) {
+    for (const worker of this.#workers.values()) {
       try {
-        const service = await this.#getServiceById(id, true, false)
-
-        // The service might be temporarily unavailable
-        if (!service) {
+        // The application might be temporarily unavailable
+        if (worker[kWorkerStatus] !== 'started') {
           continue
         }
 
-        const serviceMetrics = await sendViaITC(service, 'getMetrics', format)
-        if (serviceMetrics) {
+        const applicationMetrics = await sendViaITC(worker, 'getMetrics', format)
+        if (applicationMetrics) {
           if (metrics === null) {
             metrics = format === 'json' ? [] : ''
           }
 
           if (format === 'json') {
-            metrics.push(...serviceMetrics)
+            metrics.push(...applicationMetrics)
           } else {
-            metrics += serviceMetrics
+            metrics += applicationMetrics
           }
         }
       } catch (e) {
-        // The service exited while we were sending the ITC, skip it
-        if (e.code === 'PLT_RUNTIME_SERVICE_NOT_STARTED' || e.code === 'PLT_RUNTIME_SERVICE_EXIT') {
+        // The application exited while we were sending the ITC, skip it
+        if (
+          e.code === 'PLT_RUNTIME_APPLICATION_NOT_STARTED' ||
+          e.code === 'PLT_RUNTIME_APPLICATION_EXIT' ||
+          e.code === 'PLT_RUNTIME_APPLICATION_WORKER_EXIT'
+        ) {
           continue
         }
 
@@ -592,73 +896,105 @@ class Runtime extends EventEmitter {
     try {
       const { metrics } = await this.getMetrics()
 
-      if (metrics === null) {
+      if (metrics === null || metrics.length === 0) {
         return null
       }
 
-      const cpuMetric = metrics.find(metric => metric.name === 'process_cpu_percent_usage')
-      const rssMetric = metrics.find(metric => metric.name === 'process_resident_memory_bytes')
-      const totalHeapSizeMetric = metrics.find(metric => metric.name === 'nodejs_heap_size_total_bytes')
-      const usedHeapSizeMetric = metrics.find(metric => metric.name === 'nodejs_heap_size_used_bytes')
-      const heapSpaceSizeTotalMetric = metrics.find(metric => metric.name === 'nodejs_heap_space_size_total_bytes')
-      const newSpaceSizeTotalMetric = heapSpaceSizeTotalMetric.values.find(value => value.labels.space === 'new')
-      const oldSpaceSizeTotalMetric = heapSpaceSizeTotalMetric.values.find(value => value.labels.space === 'old')
-      const eventLoopUtilizationMetric = metrics.find(metric => metric.name === 'nodejs_eventloop_utilization')
+      const metricsNames = [
+        'process_cpu_percent_usage',
+        'process_resident_memory_bytes',
+        'nodejs_heap_size_total_bytes',
+        'nodejs_heap_size_used_bytes',
+        'nodejs_heap_space_size_total_bytes',
+        'nodejs_eventloop_utilization',
+        'http_request_all_summary_seconds'
+      ]
 
-      let p50Value = 0
-      let p90Value = 0
-      let p95Value = 0
-      let p99Value = 0
+      const applicationsMetrics = {}
 
-      const metricName = 'http_request_all_summary_seconds'
-      const httpLatencyMetrics = metrics.filter(metric => metric.name === metricName)
+      for (const metric of metrics) {
+        const { name, values } = metric
 
-      if (httpLatencyMetrics) {
-        const entrypointMetrics = httpLatencyMetrics.find(
-          metric => metric.values?.[0]?.labels?.serviceId === this.#entrypointId
-        )
-        if (entrypointMetrics) {
-          p50Value = entrypointMetrics.values.find(value => value.labels.quantile === 0.5)?.value || 0
-          p90Value = entrypointMetrics.values.find(value => value.labels.quantile === 0.9)?.value || 0
-          p95Value = entrypointMetrics.values.find(value => value.labels.quantile === 0.95)?.value || 0
-          p99Value = entrypointMetrics.values.find(value => value.labels.quantile === 0.99)?.value || 0
+        if (!metricsNames.includes(name)) continue
+        if (!values || values.length === 0) continue
+
+        const labels = values[0].labels
+        // Use the configured label name (serviceId for v2 compatibility, applicationId for v3+)
+        const applicationId = labels?.[this.#metricsLabelName]
+
+        if (!applicationId) {
+          throw new Error(`Missing ${this.#metricsLabelName} label in metrics`)
+        }
 
-          p50Value = Math.round(p50Value * 1000)
-          p90Value = Math.round(p90Value * 1000)
-          p95Value = Math.round(p95Value * 1000)
-          p99Value = Math.round(p99Value * 1000)
+        let applicationMetrics = applicationsMetrics[applicationId]
+        if (!applicationMetrics) {
+          applicationMetrics = {
+            cpu: 0,
+            rss: 0,
+            totalHeapSize: 0,
+            usedHeapSize: 0,
+            newSpaceSize: 0,
+            oldSpaceSize: 0,
+            elu: 0,
+            latency: {
+              p50: 0,
+              p90: 0,
+              p95: 0,
+              p99: 0
+            }
+          }
+          applicationsMetrics[applicationId] = applicationMetrics
         }
+
+        parsePromMetric(applicationMetrics, metric)
       }
 
-      const cpu = cpuMetric.values[0].value
-      const rss = rssMetric.values[0].value
-      const elu = eventLoopUtilizationMetric.values[0].value
-      const totalHeapSize = totalHeapSizeMetric.values[0].value
-      const usedHeapSize = usedHeapSizeMetric.values[0].value
-      const newSpaceSize = newSpaceSizeTotalMetric.value
-      const oldSpaceSize = oldSpaceSizeTotalMetric.value
+      function parsePromMetric (applicationMetrics, promMetric) {
+        const { name } = promMetric
 
-      const formattedMetrics = {
-        version: 1,
-        date: new Date().toISOString(),
-        cpu,
-        elu,
-        rss,
-        totalHeapSize,
-        usedHeapSize,
-        newSpaceSize,
-        oldSpaceSize,
-        entrypoint: {
-          latency: {
-            p50: p50Value,
-            p90: p90Value,
-            p95: p95Value,
-            p99: p99Value
+        if (name === 'process_cpu_percent_usage') {
+          applicationMetrics.cpu = promMetric.values[0].value
+          return
+        }
+        if (name === 'process_resident_memory_bytes') {
+          applicationMetrics.rss = promMetric.values[0].value
+          return
+        }
+        if (name === 'nodejs_heap_size_total_bytes') {
+          applicationMetrics.totalHeapSize = promMetric.values[0].value
+          return
+        }
+        if (name === 'nodejs_heap_size_used_bytes') {
+          applicationMetrics.usedHeapSize = promMetric.values[0].value
+          return
+        }
+        if (name === 'nodejs_heap_space_size_total_bytes') {
+          const newSpaceSize = promMetric.values.find(value => value.labels.space === 'new')
+          const oldSpaceSize = promMetric.values.find(value => value.labels.space === 'old')
+
+          applicationMetrics.newSpaceSize = newSpaceSize.value
+          applicationMetrics.oldSpaceSize = oldSpaceSize.value
+          return
+        }
+        if (name === 'nodejs_eventloop_utilization') {
+          applicationMetrics.elu = promMetric.values[0].value
+          return
+        }
+        if (name === 'http_request_all_summary_seconds') {
+          applicationMetrics.latency = {
+            p50: promMetric.values.find(value => value.labels.quantile === 0.5)?.value || 0,
+            p90: promMetric.values.find(value => value.labels.quantile === 0.9)?.value || 0,
+            p95: promMetric.values.find(value => value.labels.quantile === 0.95)?.value || 0,
+            p99: promMetric.values.find(value => value.labels.quantile === 0.99)?.value || 0
           }
         }
       }
 
-      return formattedMetrics
+      return {
+        version: 1,
+        date: new Date().toISOString(),
+        applications: applicationsMetrics
+      }
     } catch (err) {
       // If any metric is missing, return nothing
       this.logger.warn({ err }, 'Cannot fetch metrics')
@@ -667,355 +1003,1397 @@ class Runtime extends EventEmitter {
     }
   }
 
-  async getServiceMeta (id) {
-    const service = this.#services.get(id)
+  getSharedContext () {
+    return this.#sharedContext
+  }
 
-    if (!service) {
-      throw new errors.ServiceNotFoundError(id, Array.from(this.#services.keys()).join(', '))
-    }
+  async getApplicationResourcesInfo (id) {
+    const workers = this.#workers.getCount(id)
 
-    try {
-      return await sendViaITC(service, 'getServiceMeta')
-    } catch (e) {
-      // The service exports no meta, return an empty object
-      if (e.code === 'PLT_ITC_HANDLER_NOT_FOUND') {
-        return {}
-      }
+    const worker = await this.#getWorkerById(id, 0, false, false)
+    const health = worker[kConfig].health
 
-      throw e
-    }
+    return { workers, health }
   }
 
-  async getLogIds (runtimePID) {
-    runtimePID = runtimePID ?? process.pid
-
-    const runtimeLogFiles = await this.#getRuntimeLogFiles(runtimePID)
-    const runtimeLogIds = []
+  getApplicationsIds () {
+    return this.#config.applications.map(application => application.id)
+  }
 
-    for (const logFile of runtimeLogFiles) {
-      const logId = parseInt(logFile.slice('logs.'.length))
-      runtimeLogIds.push(logId)
+  async getApplications (allowUnloaded = false) {
+    return {
+      entrypoint: this.#entrypointId,
+      production: this.#isProduction,
+      applications: await Promise.all(
+        this.getApplicationsIds().map(id => this.getApplicationDetails(id, allowUnloaded))
+      )
     }
-    return runtimeLogIds
   }
 
-  async getAllLogIds () {
-    const runtimesLogFiles = await this.#getAllLogsFiles()
-    const runtimesLogsIds = []
+  async getWorkers () {
+    const status = {}
+
+    for (const [application, { count }] of Object.entries(this.#workers.configuration)) {
+      for (let i = 0; i < count; i++) {
+        const label = `${application}:${i}`
+        const worker = this.#workers.get(label)
 
-    for (const runtime of runtimesLogFiles) {
-      const runtimeLogIds = []
-      for (const logFile of runtime.runtimeLogFiles) {
-        const logId = parseInt(logFile.slice('logs.'.length))
-        runtimeLogIds.push(logId)
+        status[label] = {
+          application,
+          worker: i,
+          status: worker?.[kWorkerStatus] ?? 'exited',
+          thread: worker?.threadId
+        }
       }
-      runtimesLogsIds.push({
-        pid: runtime.runtimePID,
-        indexes: runtimeLogIds
-      })
     }
 
-    return runtimesLogsIds
+    return status
+  }
+
+  async getApplicationMeta (id) {
+    const application = await this.#getApplicationById(id)
+
+    try {
+      return await sendViaITC(application, 'getApplicationMeta')
+    } catch (e) {
+      // The application exports no meta, return an empty object
+      if (e.code === 'PLT_ITC_HANDLER_NOT_FOUND') {
+        return {}
+      }
+
+      throw e
+    }
+  }
+
+  async getApplicationDetails (id, allowUnloaded = false) {
+    let application
+
+    try {
+      application = await this.#getApplicationById(id)
+    } catch (e) {
+      if (allowUnloaded) {
+        return { id, status: 'stopped' }
+      }
+
+      throw e
+    }
+
+    const { entrypoint, localUrl } = application[kConfig]
+
+    const status = await sendViaITC(application, 'getStatus')
+    const { type, version, dependencies } = await sendViaITC(application, 'getApplicationInfo')
+
+    const applicationDetails = {
+      id,
+      type,
+      status,
+      dependencies,
+      version,
+      localUrl,
+      entrypoint
+    }
+
+    if (this.#isProduction) {
+      applicationDetails.workers = this.#workers.getCount(id)
+    }
+
+    if (entrypoint) {
+      applicationDetails.url = status === 'started' ? this.#url : null
+    }
+
+    return applicationDetails
+  }
+
+  async getApplication (id, ensureStarted = true) {
+    return this.#getApplicationById(id, ensureStarted)
+  }
+
+  async getApplicationConfig (id, ensureStarted = true) {
+    const application = await this.#getApplicationById(id, ensureStarted)
+
+    return sendViaITC(application, 'getApplicationConfig')
+  }
+
+  async getApplicationEnv (id, ensureStarted = true) {
+    const application = await this.#getApplicationById(id, ensureStarted)
+
+    return sendViaITC(application, 'getApplicationEnv')
   }
 
-  async getLogFileStream (logFileId, runtimePID) {
-    const runtimeLogsDir = this.#getRuntimeLogsDir(runtimePID)
-    const filePath = join(runtimeLogsDir, `logs.${logFileId}`)
-    return createReadStream(filePath)
+  async getApplicationOpenapiSchema (id) {
+    const application = await this.#getApplicationById(id, true)
+
+    return sendViaITC(application, 'getApplicationOpenAPISchema')
   }
 
-  #updateStatus (status) {
+  async getApplicationGraphqlSchema (id) {
+    const application = await this.#getApplicationById(id, true)
+
+    return sendViaITC(application, 'getApplicationGraphQLSchema')
+  }
+
+  #getHttpCacheValue ({ request }) {
+    if (!this.#sharedHttpCache) {
+      return
+    }
+
+    return this.#sharedHttpCache.getValue(request)
+  }
+
+  #setHttpCacheValue ({ request, response, payload }) {
+    if (!this.#sharedHttpCache) {
+      return
+    }
+
+    return this.#sharedHttpCache.setValue(request, response, payload)
+  }
+
+  #deleteHttpCacheValue ({ request }) {
+    if (!this.#sharedHttpCache) {
+      return
+    }
+
+    return this.#sharedHttpCache.delete(request)
+  }
+
+  async #setDispatcher (undiciConfig) {
+    const config = this.#config
+
+    const dispatcherOpts = { ...undiciConfig }
+    const interceptors = [this.#meshInterceptor]
+
+    if (config.httpCache) {
+      this.#sharedHttpCache = await createSharedStore(this.#root, config.httpCache)
+      interceptors.push(
+        undiciInterceptors.cache({
+          store: this.#sharedHttpCache,
+          methods: config.httpCache.methods ?? ['GET', 'HEAD']
+        })
+      )
+    }
+    this.#dispatcher = new Agent(dispatcherOpts).compose(interceptors)
+  }
+
+  #updateStatus (status, args) {
     this.#status = status
-    this.emit(status)
+    this.emit(status, args)
   }
 
   #showUrl () {
     this.logger.info(`Platformatic is now listening at ${this.#url}`)
   }
 
-  async #setupService (serviceConfig) {
-    if (this.#status === 'stopping' || this.#status === 'closed') return
+  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
+          )
 
-    const config = this.#configManager.current
-    const { autoload, restartOnError } = config
+          await this.closeAndThrow(new RuntimeAbortedError())
+        }
+      }
 
-    const id = serviceConfig.id
-    const { port1: loggerDestination, port2: loggingPort } = new MessageChannel()
-    loggerDestination.on('message', this.#forwardThreadLog.bind(this))
+      setupInvocations.push([applicationConfig])
+    }
+
+    await executeInParallel(this.#setupApplication.bind(this), setupInvocations, this.#concurrency)
+  }
 
-    if (!this.#bootstrapAttempts.has(id)) {
-      this.#bootstrapAttempts.set(id, 0)
+  async #setupApplication (applicationConfig) {
+    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++) {
+      setupInvocations.push([config, applicationConfig, workersCount, id, i])
+    }
+
+    await executeInParallel(this.#setupWorker.bind(this), setupInvocations, this.#concurrency)
+
+    this.emit('application:init', id)
+  }
+
+  async #setupWorker (config, applicationConfig, workersCount, applicationId, index, enabled = true) {
+    const { restartOnError } = config
+    const workerId = `${applicationId}:${index}`
+
+    // Handle inspector
+    let inspectorOptions
+
+    if (this.#config.inspectorOptions) {
+      inspectorOptions = {
+        ...this.#config.inspectorOptions
+      }
+
+      inspectorOptions.port = inspectorOptions.port + this.#workers.size + 1
     }
 
-    const service = new Worker(kWorkerFile, {
+    if (config.telemetry) {
+      applicationConfig.telemetry = {
+        ...config.telemetry,
+        ...applicationConfig.telemetry,
+        applicationName: `${config.telemetry.applicationName}-${applicationConfig.id}`
+      }
+    }
+
+    const errorLabel = this.#workerExtendedLabel(applicationId, index, workersCount)
+    const health = deepmerge(config.health ?? {}, applicationConfig.health ?? {})
+
+    const execArgv = []
+
+    if (!applicationConfig.skipTelemetryHooks && config.telemetry && config.telemetry.enabled !== false) {
+      const require = createRequire(import.meta.url)
+      const telemetryPath = require.resolve('@platformatic/telemetry')
+      const openTelemetrySetupPath = join(telemetryPath, '..', 'lib', 'node-telemetry.js')
+      const hookUrl = pathToFileURL(require.resolve('@opentelemetry/instrumentation/hook.mjs'))
+
+      // We need the following because otherwise some open telemetry instrumentations won't work with ESM (like express)
+      // see: https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md#instrumentation-hook-required-for-esm
+      execArgv.push('--import', `data:text/javascript, import { register } from 'node:module'; register('${hookUrl}')`)
+      execArgv.push('--import', pathToFileURL(openTelemetrySetupPath))
+    }
+
+    if ((applicationConfig.sourceMaps ?? config.sourceMaps) === true) {
+      execArgv.push('--enable-source-maps')
+    }
+
+    const workerEnv = structuredClone(this.#env)
+
+    if (applicationConfig.nodeOptions?.trim().length > 0) {
+      const originalNodeOptions = workerEnv['NODE_OPTIONS'] ?? ''
+
+      workerEnv['NODE_OPTIONS'] = `${originalNodeOptions} ${applicationConfig.nodeOptions}`.trim()
+    }
+
+    const maxHeapTotal =
+      typeof health.maxHeapTotal === 'string' ? parseMemorySize(health.maxHeapTotal) : health.maxHeapTotal
+    const maxYoungGeneration =
+      typeof health.maxYoungGeneration === 'string'
+        ? parseMemorySize(health.maxYoungGeneration)
+        : health.maxYoungGeneration
+
+    const maxOldGenerationSizeMb = Math.floor(
+      (maxYoungGeneration > 0 ? maxHeapTotal - maxYoungGeneration : maxHeapTotal) / (1024 * 1024)
+    )
+    const maxYoungGenerationSizeMb = maxYoungGeneration ? Math.floor(maxYoungGeneration / (1024 * 1024)) : undefined
+
+    const worker = new Worker(kWorkerFile, {
       workerData: {
         config,
-        serviceConfig: {
-          ...serviceConfig,
-          isProduction: this.#configManager.args?.production ?? false
+        applicationConfig: {
+          ...applicationConfig,
+          isProduction: this.#isProduction,
+          configPatch: this.#applicationsConfigsPatches.get(applicationId)
+        },
+        worker: {
+          id: workerId,
+          index,
+          count: workersCount
         },
-        dirname: this.#configManager.dirname,
-        runtimeLogsDir: this.#runtimeLogsDir,
-        loggingPort
+        inspectorOptions,
+        dirname: this.#root
+      },
+      argv: applicationConfig.arguments,
+      execArgv,
+      env: workerEnv,
+      resourceLimits: {
+        maxOldGenerationSizeMb,
+        maxYoungGenerationSizeMb
       },
-      execArgv: [], // Avoid side effects
-      env: this.#env,
-      transferList: [loggingPort],
-      /*
-        Important: always set stdout and stderr to true, so that worker's output is not automatically
-        piped to the parent thread. We actually never output the thread output since we replace it
-        with PinoWritable, and disabling the piping avoids us to redeclare some internal Node.js methods.
-
-        The author of this (Paolo and Matteo) are not proud of the solution. Forgive us.
-      */
       stdout: true,
       stderr: true
     })
 
+    this.#handleWorkerStandardStreams(worker, applicationId, workersCount > 1 ? index : undefined)
+
     // Make sure the listener can handle a lot of API requests at once before raising a warning
-    service.setMaxListeners(1e3)
+    worker.setMaxListeners(1e3)
+
+    // Track application exiting
+    const eventPayload = { application: applicationId, worker: index, workersCount }
 
-    // Track service exiting
-    service.once('exit', code => {
-      const started = this.#startedServices.get(id)
-      this.#services.delete(id)
-      loggerDestination.close()
-      service[kITC].close()
-      loggingPort.close()
+    worker.once('exit', code => {
+      if (worker[kWorkerStatus] === 'exited') {
+        return
+      }
 
-      if (this.#status === 'stopping') return
+      const started = worker[kWorkerStatus] === 'started'
+      worker[kWorkerStatus] = 'exited'
+      this.emit('application:worker:exited', eventPayload)
+
+      this.#cleanupWorker(worker)
+
+      if (this.#status === 'stopping') {
+        return
+      }
 
       // Wait for the next tick so that crashed from the thread are logged first
       setImmediate(() => {
-        if (!config.watch || code !== 0) {
-          this.logger.warn(`Service "${id}" unexpectedly exited with code ${code}.`)
+        if (started && (!config.watch || code !== 0)) {
+          this.emit('application:worker:error', { ...eventPayload, code })
+          this.#broadcastWorkers()
+
+          this.logger.warn(`The ${errorLabel} unexpectedly exited with code ${code}.`)
         }
 
-        // Restart the service if it was started
+        // Restart the application if it was started
         if (started && this.#status === 'started') {
           if (restartOnError > 0) {
-            this.logger.warn(`Restarting a service "${id}" in ${restartOnError}ms...`)
-            this.#restartCrashedService(id).catch(err => {
-              this.logger.error({ err: ensureLoggableError(err) }, `Failed to restart service "${id}".`)
-            })
+            if (restartOnError < IMMEDIATE_RESTART_MAX_THRESHOLD) {
+              this.logger.warn(`The ${errorLabel} is being restarted ...`)
+            } else {
+              this.logger.warn(`The ${errorLabel} will be restarted in ${restartOnError}ms ...`)
+            }
+
+            this.#restartCrashedWorker(config, applicationConfig, workersCount, applicationId, index, false, 0).catch(
+              err => {
+                this.logger.error({ err: ensureLoggableError(err) }, `${errorLabel} could not be restarted.`)
+              }
+            )
           } else {
-            this.logger.warn(`The "${id}" service is no longer available.`)
+            this.emit('application:worker:unvailable', eventPayload)
+            this.logger.warn(`The ${errorLabel} is no longer available.`)
           }
         }
       })
     })
 
-    service[kId] = id
-    service[kConfig] = serviceConfig
+    worker[kId] = workersCount > 1 ? workerId : applicationId
+    worker[kFullId] = workerId
+    worker[kApplicationId] = applicationId
+    worker[kWorkerId] = workersCount > 1 ? index : undefined
+    worker[kWorkerStatus] = 'boot'
 
-    // Setup ITC
-    service[kITC] = new ITC({
-      name: id + '-runtime',
-      port: service,
-      handlers: {
-        getServiceMeta: this.getServiceMeta.bind(this),
-        getServices: this.getServices.bind(this)
+    if (inspectorOptions) {
+      worker[kInspectorOptions] = {
+        port: inspectorOptions.port,
+        id: applicationId,
+        dirname: this.#root
       }
+    }
+
+    // Setup ITC
+    worker[kITC] = new ITC({
+      name: workerId + '-runtime',
+      port: worker,
+      handlers: this.#workerITCHandlers
+    })
+    worker[kITC].listen()
+
+    // Forward events from the worker
+    worker[kITC].on('event', ({ event, payload }) => {
+      this.emit(`application:worker:event:${event}`, { ...eventPayload, payload })
     })
-    service[kITC].listen()
 
-    // Handle services changes
-    // This is not purposely activated on when this.#configManager.current.watch === true
-    // so that services can eventually manually trigger a restart. This mechanism is current
-    // used by the composer
-    service[kITC].on('changed', async () => {
+    // Only activate watch for the first instance
+    if (index === 0) {
+      // Handle applications changes
+      // This is not purposely activated on when this.#config.watch === true
+      // so that applications can eventually manually trigger a restart. This mechanism is current
+      // used by the gateway.
+      worker[kITC].on('changed', async () => {
+        this.emit('application:worker:changed', eventPayload)
+
+        try {
+          const wasStarted = worker[kWorkerStatus].startsWith('start')
+          await this.stopApplication(applicationId)
+
+          if (wasStarted) {
+            await this.startApplication(applicationId)
+          }
+
+          this.logger.info(`The application "${applicationId}" has been successfully reloaded ...`)
+          this.emit('application:worker:reloaded', eventPayload)
+
+          if (applicationConfig.entrypoint) {
+            this.#showUrl()
+          }
+        } catch (e) {
+          this.logger.error(e)
+        }
+      })
+    }
+
+    if (enabled) {
+      // Store locally
+      this.#workers.set(workerId, worker)
+
+      // Setup the interceptor
+      this.#meshInterceptor.route(applicationId, worker)
+    }
+
+    // Wait for initialization
+    await waitEventFromITC(worker, 'init')
+
+    if (applicationConfig.entrypoint) {
+      this.#entrypointId = applicationId
+    }
+
+    worker[kConfig] = { ...applicationConfig, health, workers: workersCount }
+    worker[kWorkerStatus] = 'init'
+    this.emit('application:worker:init', eventPayload)
+
+    return worker
+  }
+
+  async #getHealth (worker) {
+    if (features.node.worker.getHeapStatistics) {
+      const { used_heap_size: heapUsed, total_heap_size: heapTotal } = await worker.getHeapStatistics()
+      const currentELU = worker.performance.eventLoopUtilization()
+      const elu = worker[kLastELU] ? worker.performance.eventLoopUtilization(currentELU, worker[kLastELU]) : currentELU
+      worker[kLastELU] = currentELU
+      return { elu: elu.utilization, heapUsed, heapTotal }
+    }
+
+    const health = await worker[kITC].send('getHealth')
+    return health
+  }
+
+  #setupHealthCheck (config, applicationConfig, workersCount, id, index, worker, errorLabel) {
+    // Clear the timeout when exiting
+    worker.on('exit', () => clearTimeout(worker[kHealthCheckTimer]))
+
+    const { maxELU, maxHeapUsed, maxHeapTotal, maxUnhealthyChecks, interval } = worker[kConfig].health
+    const maxHeapTotalNumber = typeof maxHeapTotal === 'string' ? parseMemorySize(maxHeapTotal) : maxHeapTotal
+
+    let unhealthyChecks = 0
+
+    worker[kHealthCheckTimer] = setTimeout(async () => {
+      if (worker[kWorkerStatus] !== 'started') {
+        return
+      }
+
+      let health, unhealthy, memoryUsage
       try {
-        const wasStarted = this.#startedServices.get(id)
+        health = await this.#getHealth(worker)
+        memoryUsage = health.heapUsed / maxHeapTotalNumber
+        unhealthy = health.elu > maxELU || memoryUsage > maxHeapUsed
+      } catch (err) {
+        this.logger.error({ err }, `Failed to get health for ${errorLabel}.`)
+        unhealthy = true
+        memoryUsage = -1
+        health = { elu: -1, heapUsed: -1, heapTotal: -1 }
+      }
 
-        await this._stopService(id)
+      this.emit('application:worker:health', {
+        id: worker[kId],
+        application: id,
+        worker: index,
+        currentHealth: health,
+        unhealthy,
+        healthConfig: worker[kConfig].health
+      })
+
+      if (unhealthy) {
+        if (health.elu > maxELU) {
+          this.logger.error(
+            `The ${errorLabel} has an ELU of ${(health.elu * 100).toFixed(2)} %, above the maximum allowed usage of ${(maxELU * 100).toFixed(2)} %.`
+          )
+        }
 
-        if (wasStarted) {
-          await this.startService(id)
+        if (memoryUsage > maxHeapUsed) {
+          this.logger.error(
+            `The ${errorLabel} is using ${(memoryUsage * 100).toFixed(2)} % of the memory, above the maximum allowed usage of ${(maxHeapUsed * 100).toFixed(2)} %.`
+          )
         }
 
-        this.logger?.info(`Service ${id} has been successfully reloaded ...`)
+        unhealthyChecks++
+      } else {
+        unhealthyChecks = 0
+      }
+
+      if (unhealthyChecks === maxUnhealthyChecks) {
+        try {
+          this.emit('application:worker:unhealthy', { application: id, worker: index })
 
-        if (serviceConfig.entrypoint) {
-          this.#showUrl()
+          this.logger.error(
+            { elu: health.elu, maxELU, memoryUsage: health.heapUsed, maxMemoryUsage: maxHeapUsed },
+            `The ${errorLabel} is unhealthy. Replacing it ...`
+          )
+
+          await this.#replaceWorker(config, applicationConfig, workersCount, id, index, worker)
+        } catch (e) {
+          this.logger.error(
+            { elu: health.elu, maxELU, memoryUsage: health.heapUsed, maxMemoryUsage: maxHeapUsed },
+            `Cannot replace the ${errorLabel}. Forcefully terminating it ...`
+          )
+
+          worker.terminate()
         }
-      } catch (e) {
-        this.logger?.error(e)
+      } else {
+        worker[kHealthCheckTimer].refresh()
       }
-    })
+    }, interval)
+  }
 
-    // Store locally
-    this.#services.set(id, service)
+  async #startWorker (
+    config,
+    applicationConfig,
+    workersCount,
+    id,
+    index,
+    silent,
+    bootstrapAttempt = 0,
+    worker = undefined,
+    disableRestartAttempts = false
+  ) {
+    const label = this.#workerExtendedLabel(id, index, workersCount)
 
-    if (serviceConfig.entrypoint) {
-      this.#entrypoint = service
-      this.#entrypointId = id
+    if (!silent) {
+      this.logger.info(`Starting the ${label}...`)
     }
 
-    // Setup the interceptor
-    this.#interceptor.route(id, service)
+    if (!worker) {
+      worker = await this.#getWorkerById(id, index, false, false)
+    }
+
+    const eventPayload = { application: id, worker: index, workersCount }
+
+    // The application was stopped, recreate the thread
+    if (!worker) {
+      await this.#setupApplication(applicationConfig, index)
+      worker = await this.#getWorkerById(id, index)
+    }
 
-    // Store dependencies
-    const [{ dependencies }] = await waitEventFromITC(service, 'init')
+    worker[kWorkerStatus] = 'starting'
+    this.emit('application:worker:starting', eventPayload)
 
-    if (autoload) {
-      serviceConfig.dependencies = dependencies
-      for (const { envVar, url } of dependencies) {
-        if (envVar) {
-          serviceConfig.localServiceEnvVars.set(envVar, url)
+    try {
+      let workerUrl
+      if (config.startTimeout > 0) {
+        workerUrl = await executeWithTimeout(sendViaITC(worker, 'start'), config.startTimeout)
+
+        if (workerUrl === kTimeout) {
+          this.emit('application:worker:startTimeout', eventPayload)
+          this.logger.info(`The ${label} failed to start in ${config.startTimeout}ms. Forcefully killing the thread.`)
+          worker.terminate()
+          throw new ApplicationStartTimeoutError(id, config.startTimeout)
         }
+      } else {
+        workerUrl = await sendViaITC(worker, 'start')
+      }
+
+      await this.#avoidOutOfOrderThreadLogs()
+
+      if (workerUrl) {
+        this.#url = workerUrl
+      }
+
+      worker[kWorkerStatus] = 'started'
+      this.emit('application:worker:started', eventPayload)
+      this.#broadcastWorkers()
+
+      if (!silent) {
+        this.logger.info(`Started the ${label}...`)
+      }
+
+      const { enabled, gracePeriod } = worker[kConfig].health
+      if (enabled && config.restartOnError > 0) {
+        // if gracePeriod is 0, it will be set to 1 to start health checks immediately
+        // however, the health event will start when the worker is started
+        setTimeout(
+          () => {
+            this.#setupHealthCheck(config, applicationConfig, workersCount, id, index, worker, label)
+          },
+          gracePeriod > 0 ? gracePeriod : 1
+        ).unref()
       }
+    } 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
+
+      this.#cleanupWorker(worker)
+
+      if (worker[kWorkerStatus] !== 'exited') {
+        // This prevent the exit handler to restart application
+        worker[kWorkerStatus] = 'exited'
+
+        // Wait for the worker to exit gracefully, otherwise we terminate it
+        const waitTimeout = await executeWithTimeout(once(worker, 'exit'), config.gracefulShutdown.application)
+
+        if (waitTimeout === kTimeout) {
+          await worker.terminate()
+        }
+      }
+
+      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}: ${error.message}`)
+      }
+
+      const restartOnError = config.restartOnError
+
+      if (disableRestartAttempts || !restartOnError) {
+        throw error
+      }
+
+      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
+      }
+
+      if (restartOnError < IMMEDIATE_RESTART_MAX_THRESHOLD) {
+        this.logger.warn(
+          `Performing attempt ${bootstrapAttempt} of ${MAX_BOOTSTRAP_ATTEMPTS} to start the ${label} again ...`
+        )
+      } else {
+        this.logger.warn(
+          `Attempt ${bootstrapAttempt} of ${MAX_BOOTSTRAP_ATTEMPTS} to start the ${label} again will be performed in ${restartOnError}ms ...`
+        )
+      }
+
+      await this.#restartCrashedWorker(config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt)
     }
   }
 
-  async #restartCrashedService (id) {
-    const config = this.#configManager.current
-    const serviceConfig = config.services.find(s => s.id === id)
+  async #stopWorker (workersCount, id, index, silent, worker, dependents) {
+    if (!worker) {
+      worker = await this.#getWorkerById(id, index, false, false)
+    }
 
-    let restartPromise = this.#restartPromises.get(id)
+    if (!worker) {
+      return
+    }
+
+    // Boot should be aborted, discard the worker
+    if (worker[kWorkerStatus] === 'boot') {
+      return this.#discardWorker(worker)
+    }
+
+    const eventPayload = { application: id, worker: index, workersCount }
+
+    worker[kWorkerStatus] = 'stopping'
+    worker[kITC].removeAllListeners('changed')
+    this.emit('application:worker:stopping', eventPayload)
+
+    const label = this.#workerExtendedLabel(id, index, workersCount)
+
+    if (!silent) {
+      this.logger.info(`Stopping the ${label}...`)
+    }
+
+    const exitTimeout = this.#config.gracefulShutdown.application
+    const exitPromise = once(worker, 'exit')
+
+    // Always send the stop message, it will shut down workers that only had ITC and interceptors setup
+    try {
+      await executeWithTimeout(sendViaITC(worker, 'stop', { force: !!this.error, dependents }), exitTimeout)
+    } catch (error) {
+      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()
+    }
+
+    if (!silent) {
+      this.logger.info(`Stopped the ${label}...`)
+    }
+
+    // Wait for the worker thread to finish, we're going to create a new one if the application is ever restarted
+    const res = await executeWithTimeout(exitPromise, exitTimeout)
+
+    // If the worker didn't exit in time, kill it
+    if (res === kTimeout) {
+      this.emit('application:worker:exit:timeout', eventPayload)
+      await worker.terminate()
+    }
+
+    await this.#avoidOutOfOrderThreadLogs()
+
+    worker[kWorkerStatus] = 'stopped'
+    this.emit('application:worker:stopped', eventPayload)
+    this.#broadcastWorkers()
+  }
+
+  #cleanupWorker (worker) {
+    clearTimeout(worker[kHealthCheckTimer])
+
+    const currentWorker = this.#workers.get(worker[kFullId])
+
+    if (currentWorker === worker) {
+      this.#workers.delete(worker[kFullId])
+    }
+
+    worker[kITC].close()
+  }
+
+  async #discardWorker (worker) {
+    this.#meshInterceptor.unroute(worker[kApplicationId], worker, true)
+    worker.removeAllListeners('exit')
+    await worker.terminate()
+
+    return this.#cleanupWorker(worker)
+  }
+
+  #workerExtendedLabel (applicationId, workerId, workersCount) {
+    return workersCount > 1
+      ? `worker ${workerId} of the application "${applicationId}"`
+      : `application "${applicationId}"`
+  }
+
+  async #restartCrashedWorker (config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt) {
+    const workerId = `${id}:${index}`
+
+    let restartPromise = this.#restartingWorkers.get(workerId)
     if (restartPromise) {
       await restartPromise
       return
     }
 
     restartPromise = new Promise((resolve, reject) => {
-      setTimeout(async () => {
-        this.#restartPromises.delete(id)
+      async function restart () {
+        this.#restartingWorkers.delete(workerId)
 
-        try {
-          await this.#setupService(serviceConfig)
+        // If some processes were scheduled to restart
+        // but the runtime is stopped, ignore it
+        if (!this.#status.startsWith('start')) {
+          return
+        }
 
-          const started = this.#startedServices.get(id)
-          if (started) {
-            this.#startedServices.set(id, false)
-            await this.startService(id)
-          }
+        try {
+          await this.#setupWorker(config, applicationConfig, workersCount, id, index)
+          await this.#startWorker(config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt)
 
+          this.logger.info(
+            `The ${this.#workerExtendedLabel(id, index, workersCount)} has been successfully restarted ...`
+          )
           resolve()
         } catch (err) {
+          // The runtime was stopped while the restart was happening, ignore any error.
+          if (!this.#status.startsWith('start')) {
+            resolve()
+          }
+
           reject(err)
         }
-      }, config.restartOnError)
+      }
+
+      if (config.restartOnError < IMMEDIATE_RESTART_MAX_THRESHOLD) {
+        process.nextTick(restart.bind(this))
+      } else {
+        setTimeout(restart.bind(this), config.restartOnError)
+      }
     })
 
-    this.#restartPromises.set(id, restartPromise)
+    this.#restartingWorkers.set(workerId, restartPromise)
     await restartPromise
   }
 
-  async #getServiceById (id, ensureStarted = false, mustExist = true) {
-    const service = this.#services.get(id)
+  async #replaceWorker (config, applicationConfig, workersCount, applicationId, index, worker) {
+    const workerId = `${applicationId}:${index}`
+    let newWorker
+
+    try {
+      // Create a new worker
+      newWorker = await this.#setupWorker(config, applicationConfig, workersCount, applicationId, index, false)
+
+      // Make sure the runtime hasn't been stopped in the meanwhile
+      if (this.#status !== 'started') {
+        return this.#discardWorker(newWorker)
+      }
+
+      // Add the worker to the mesh
+      await this.#startWorker(config, applicationConfig, workersCount, applicationId, index, false, 0, newWorker, true)
+
+      // Make sure the runtime hasn't been stopped in the meanwhile
+      if (this.#status !== 'started') {
+        return this.#discardWorker(newWorker)
+      }
+
+      this.#workers.set(workerId, newWorker)
+      this.#meshInterceptor.route(applicationId, newWorker)
+
+      // Remove the old worker and then kill it
+      await sendViaITC(worker, 'removeFromMesh')
+    } catch (e) {
+      newWorker?.terminate?.()
+      throw e
+    }
+
+    await this.#stopWorker(workersCount, applicationId, index, false, worker, [])
+  }
+
+  async #getApplicationById (applicationId, ensureStarted = false, mustExist = true) {
+    // If the applicationId includes the worker, properly split
+    let workerId
+    const matched = applicationId.match(/^(.+):(\d+)$/)
+
+    if (matched) {
+      applicationId = matched[1]
+      workerId = matched[2]
+    }
+
+    return this.#getWorkerById(applicationId, workerId, ensureStarted, mustExist)
+  }
+
+  async #getWorkerById (applicationId, workerId, ensureStarted = false, mustExist = true) {
+    let worker
+
+    if (typeof workerId !== 'undefined') {
+      worker = this.#workers.get(`${applicationId}:${workerId}`)
+    } else {
+      worker = this.#workers.next(applicationId)
+    }
+
+    const applicationsIds = this.getApplicationsIds()
 
-    if (!service) {
-      if (!mustExist && this.#servicesIds.includes(id)) {
+    if (!worker) {
+      if (!mustExist && applicationsIds.includes(applicationId)) {
         return null
       }
 
-      throw new errors.ServiceNotFoundError(id, Array.from(this.#services.keys()).join(', '))
+      if (applicationsIds.includes(applicationId)) {
+        const availableWorkers = Array.from(this.#workers.keys())
+          .filter(key => key.startsWith(applicationId + ':'))
+          .map(key => key.split(':')[1])
+          .join(', ')
+        throw new WorkerNotFoundError(workerId, applicationId, availableWorkers)
+      } else {
+        throw new ApplicationNotFoundError(applicationId, applicationsIds.join(', '))
+      }
     }
 
     if (ensureStarted) {
-      const serviceStatus = await sendViaITC(service, 'getStatus')
+      const applicationStatus = await sendViaITC(worker, 'getStatus')
 
-      if (serviceStatus !== 'started') {
-        throw new errors.ServiceNotStartedError(id)
+      if (applicationStatus !== 'started') {
+        throw new ApplicationNotStartedError(applicationId)
       }
     }
 
-    return service
+    return worker
+  }
+
+  async #createWorkersBroadcastChannel () {
+    this.#workersBroadcastChannel?.close()
+    this.#workersBroadcastChannel = new BroadcastChannel(kWorkersBroadcast)
+  }
+
+  async #broadcastWorkers () {
+    const workers = new Map()
+
+    // Create the list of workers
+    for (const worker of this.#workers.values()) {
+      if (worker[kWorkerStatus] !== 'started') {
+        continue
+      }
+
+      const application = worker[kApplicationId]
+      let applicationWorkers = workers.get(application)
+
+      if (!applicationWorkers) {
+        applicationWorkers = []
+        workers.set(application, applicationWorkers)
+      }
+
+      applicationWorkers.push({
+        id: worker[kId],
+        application: worker[kApplicationId],
+        worker: worker[kWorkerId],
+        thread: worker.threadId
+      })
+    }
+
+    try {
+      this.#workersBroadcastChannel.postMessage(workers)
+    } catch (err) {
+      this.logger?.error({ err }, 'Error when broadcasting workers')
+    }
+  }
+
+  async #getWorkerMessagingChannel ({ application, worker }, context) {
+    const target = await this.#getWorkerById(application, worker, true, true)
+
+    const { port1, port2 } = new MessageChannel()
+
+    // Send the first port to the target
+    const response = await executeWithTimeout(
+      sendViaITC(target, 'saveMessagingChannel', port1, [port1]),
+      this.#config.messagingTimeout
+    )
+
+    if (response === kTimeout) {
+      throw new MessagingError(application, 'Timeout while establishing a communication channel.')
+    }
+
+    context.transferList = [port2]
+    this.emit('application:worker:messagingChannel', { application, worker })
+    return port2
   }
 
   async #getRuntimePackageJson () {
-    const runtimeDir = this.#configManager.dirname
+    const runtimeDir = this.#root
     const packageJsonPath = join(runtimeDir, 'package.json')
     const packageJsonFile = await readFile(packageJsonPath, 'utf8')
     const packageJson = JSON.parse(packageJsonFile)
     return packageJson
   }
 
-  #getRuntimeLogsDir (runtimePID) {
-    return join(this.#runtimeTmpDir, runtimePID.toString(), 'logs')
+  #handleWorkerStandardStreams (worker, applicationId, workerId) {
+    const binding = { name: applicationId }
+
+    if (typeof workerId !== 'undefined') {
+      binding.worker = workerId
+    }
+
+    const logger = this.logger.child(binding, { level: 'trace' })
+
+    const selectors = {
+      stdout: { level: 'info', caller: 'STDOUT' },
+      stderr: { level: 'error', caller: 'STDERR' }
+    }
+
+    worker.stdout.setEncoding('utf8')
+    worker.stdout.on('data', raw => {
+      if (raw.includes(kStderrMarker)) {
+        this.#forwardThreadLog(logger, selectors.stderr, raw.replaceAll(kStderrMarker, ''), 'stderr')
+      } else {
+        this.#forwardThreadLog(logger, selectors.stdout, raw, 'stdout')
+      }
+    })
+
+    // Whatever is outputted here, it come from a direct process.stderr.write in the thread.
+    // There's nothing we can do about it in regard of out of order logs due to a Node bug.
+    worker.stderr.setEncoding('utf8')
+    worker.stderr.on('data', raw => {
+      this.#forwardThreadLog(logger, selectors.stderr, raw, 'stderr')
+    })
   }
 
-  async #getRuntimeLogFiles (runtimePID) {
-    const runtimeLogsDir = this.#getRuntimeLogsDir(runtimePID)
-    const runtimeLogsFiles = await readdir(runtimeLogsDir)
-    return runtimeLogsFiles
-      .filter(file => file.startsWith('logs'))
-      .sort((log1, log2) => {
-        const index1 = parseInt(log1.slice('logs.'.length))
-        const index2 = parseInt(log2.slice('logs.'.length))
-        return index1 - index2
-      })
+  // label is the key in the logger object, either 'stdout' or 'stderr'
+  #forwardThreadLog (logger, { level, caller }, data, label) {
+    // When captureStdio is false, write directly to the logger destination
+    if (!this.#config.logger.captureStdio) {
+      this.#stdio[label].write(data)
+      return
+    }
+
+    let plainMessages = ''
+    for (const raw of data.split('\n')) {
+      // First of all, try to parse the message as JSON
+      let message
+      let json
+      // The message is a JSON object if it has at least 2 bytes
+      if (raw.length >= 2) {
+        try {
+          message = JSON.parse(raw)
+          json = true
+        } catch {
+          // No-op, we assume the message is raw
+        }
+      }
+
+      const pinoLog =
+        typeof message?.level === 'number' && typeof message?.time === 'number' && typeof message?.msg === 'string'
+
+      // Directly write to the Pino destination
+      if (pinoLog) {
+        if (!this.#loggerDestination) {
+          continue
+        }
+
+        this.#loggerDestination.lastLevel = message.level
+        this.#loggerDestination.lastTime = message.time
+        this.#loggerDestination.lastMsg = message.msg
+        this.#loggerDestination.lastObj = message
+        this.#loggerDestination.lastLogger = logger
+        this.#loggerDestination.write(raw + '\n')
+        continue
+      }
+
+      if (json) {
+        logger[level]({ caller, [label]: message })
+        continue
+      }
+
+      // Not a Pino JSON nor a JSON object, accumulate the message
+      if (!pinoLog && !json) {
+        plainMessages += (plainMessages.length ? '\n' : '') + raw
+      }
+    }
+
+    // Write whatever is left
+    if (plainMessages.length > 0) {
+      logger[level]({ caller }, plainMessages.replace(/\n$/, ''))
+    }
   }
 
-  async #getAllLogsFiles () {
-    try {
-      await access(this.#runtimeTmpDir)
-    } catch (err) {
-      this.logger.error({ err: ensureLoggableError(err) }, 'Cannot access temporary folder.')
-      return []
+  // Due to Worker Threads implementation via MessagePort, it might happen that if two messages are printed almost
+  // at the same time from a worker and the main thread, the latter always arrives first.
+  // Let's wait few more ticks to ensure the right order.
+  async #avoidOutOfOrderThreadLogs () {
+    for (let i = 0; i < 2; i++) {
+      await immediate()
     }
+  }
 
-    const runtimePIDs = await readdir(this.#runtimeTmpDir)
-    const runtimesLogFiles = []
+  async #updateApplicationConfigWorkers (applicationId, workers) {
+    this.logger.info(`Updating application "${applicationId}" config workers to ${workers}`)
 
-    for (const runtimePID of runtimePIDs) {
-      const runtimeLogsDir = this.#getRuntimeLogsDir(runtimePID)
-      const runtimeLogsDirStat = await stat(runtimeLogsDir)
-      const runtimeLogFiles = await this.#getRuntimeLogFiles(runtimePID)
-      const lastModified = runtimeLogsDirStat.mtime
+    this.#config.applications.find(s => s.id === applicationId).workers = workers
+    const application = await this.#getApplicationById(applicationId)
+    this.#workers.setCount(applicationId, workers)
+    application[kConfig].workers = workers
 
-      runtimesLogFiles.push({
-        runtimePID: parseInt(runtimePID),
-        runtimeLogFiles,
-        lastModified
-      })
+    const promises = []
+    for (const [workerId, worker] of this.#workers.entries()) {
+      if (workerId.startsWith(`${applicationId}:`)) {
+        promises.push(sendViaITC(worker, 'updateWorkersCount', { applicationId, workers }))
+      }
     }
 
-    return runtimesLogFiles.sort((runtime1, runtime2) => runtime1.lastModified - runtime2.lastModified)
+    const results = await Promise.allSettled(promises)
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        this.logger.error({ err: result.reason }, `Cannot update application "${applicationId}" workers`)
+        throw result.reason
+      }
+    }
   }
 
-  #forwardThreadLog (message) {
-    if (!this.#loggerDestination) {
-      return
+  async #updateApplicationConfigHealth (applicationId, health) {
+    this.logger.info(`Updating application "${applicationId}" config health heap to ${JSON.stringify(health)}`)
+    const { maxHeapTotal, maxYoungGeneration } = health
+
+    const application = this.#config.applications.find(s => s.id === applicationId)
+    if (maxHeapTotal) {
+      application.health.maxHeapTotal = maxHeapTotal
+    }
+    if (maxYoungGeneration) {
+      application.health.maxYoungGeneration = maxYoungGeneration
+    }
+  }
+
+  async #validateUpdateApplicationResources (updates) {
+    if (!Array.isArray(updates)) {
+      throw new InvalidArgumentError('updates', 'must be an array')
+    }
+    if (updates.length === 0) {
+      throw new InvalidArgumentError('updates', 'must have at least one element')
     }
 
-    for (const log of message.logs) {
-      // In order to being able to forward messages serialized in the
-      // worker threads by directly writing to the destinations using multistream
-      // we unfortunately need to reparse the message to set some internal flags
-      // of the destination which are never set since we bypass pino.
-      let message = JSON.parse(log)
-      let { level, time, msg, raw } = message
+    const config = this.#config
+    const validatedUpdates = []
+    for (const update of updates) {
+      const { application: applicationId } = update
 
-      try {
-        const parsed = JSON.parse(raw.trimEnd())
+      if (!applicationId) {
+        throw new InvalidArgumentError('application', 'must be a string')
+      }
+      const applicationConfig = config.applications.find(s => s.id === applicationId)
+      if (!applicationConfig) {
+        throw new ApplicationNotFoundError(applicationId, Array.from(this.getApplicationsIds()).join(', '))
+      }
 
-        if (typeof parsed.level === 'number' && typeof parsed.time === 'number') {
-          level = parsed.level
-          time = parsed.time
-          message = parsed
+      const { workers: currentWorkers, health: currentHealth } = await this.getApplicationResourcesInfo(applicationId)
+
+      let workers
+      if (update.workers !== undefined) {
+        if (typeof update.workers !== 'number') {
+          throw new InvalidArgumentError('workers', 'must be a number')
+        }
+        if (update.workers <= 0) {
+          throw new InvalidArgumentError('workers', 'must be greater than 0')
+        }
+        if (update.workers > MAX_WORKERS) {
+          throw new InvalidArgumentError('workers', `must be less than ${MAX_WORKERS}`)
+        }
+
+        if (currentWorkers === update.workers) {
+          this.logger.warn(
+            { applicationId, workers: update.workers },
+            'No change in the number of workers for application'
+          )
         } else {
-          message.raw = undefined
-          message.payload = parsed
+          workers = update.workers
+        }
+      }
+
+      let maxHeapTotal, maxYoungGeneration
+      if (update.health) {
+        if (update.health.maxHeapTotal !== undefined) {
+          if (typeof update.health.maxHeapTotal === 'string') {
+            try {
+              maxHeapTotal = parseMemorySize(update.health.maxHeapTotal)
+            } catch {
+              throw new InvalidArgumentError('maxHeapTotal', 'must be a valid memory size')
+            }
+          } else if (typeof update.health.maxHeapTotal === 'number') {
+            maxHeapTotal = update.health.maxHeapTotal
+            if (update.health.maxHeapTotal <= 0) {
+              throw new InvalidArgumentError('maxHeapTotal', 'must be greater than 0')
+            }
+          } else {
+            throw new InvalidArgumentError('maxHeapTotal', 'must be a number or a string representing a memory size')
+          }
+
+          if (currentHealth.maxHeapTotal === maxHeapTotal) {
+            this.logger.warn({ applicationId, maxHeapTotal }, 'No change in the max heap total for application')
+            maxHeapTotal = undefined
+          }
+        }
+
+        if (update.health.maxYoungGeneration !== undefined) {
+          if (typeof update.health.maxYoungGeneration === 'string') {
+            try {
+              maxYoungGeneration = parseMemorySize(update.health.maxYoungGeneration)
+            } catch {
+              throw new InvalidArgumentError('maxYoungGeneration', 'must be a valid memory size')
+            }
+          } else if (typeof update.health.maxYoungGeneration === 'number') {
+            maxYoungGeneration = update.health.maxYoungGeneration
+            if (update.health.maxYoungGeneration <= 0) {
+              throw new InvalidArgumentError('maxYoungGeneration', 'must be greater than 0')
+            }
+          } else {
+            throw new InvalidArgumentError(
+              'maxYoungGeneration',
+              'must be a number or a string representing a memory size'
+            )
+          }
+
+          if (currentHealth.maxYoungGeneration && currentHealth.maxYoungGeneration === maxYoungGeneration) {
+            this.logger.warn(
+              { applicationId, maxYoungGeneration },
+              'No change in the max young generation for application'
+            )
+            maxYoungGeneration = undefined
+          }
         }
-      } catch {
-        if (typeof message.raw === 'string') {
-          message.msg = message.raw.replace(/\n$/, '')
+      }
+
+      if (workers || maxHeapTotal || maxYoungGeneration) {
+        let health
+        if (maxHeapTotal || maxYoungGeneration) {
+          health = {}
+          if (maxHeapTotal) {
+            health.maxHeapTotal = maxHeapTotal
+          }
+          if (maxYoungGeneration) {
+            health.maxYoungGeneration = maxYoungGeneration
+          }
         }
+        validatedUpdates.push({
+          applicationId,
+          config: applicationConfig,
+          workers,
+          health,
+          currentWorkers,
+          currentHealth
+        })
+      }
+    }
+
+    return validatedUpdates
+  }
+
+  async #updateApplicationWorkersAndHealth (
+    applicationId,
+    config,
+    applicationConfig,
+    workers,
+    health,
+    currentWorkers,
+    currentHealth
+  ) {
+    if (currentWorkers > workers) {
+      // stop workers
+      const reportWorkers = await this.#updateApplicationWorkers(
+        applicationId,
+        config,
+        applicationConfig,
+        workers,
+        currentWorkers
+      )
+      // update heap for current workers
+      const reportHealth = await this.#updateApplicationHealth(
+        applicationId,
+        config,
+        applicationConfig,
+        workers,
+        currentHealth,
+        health
+      )
+
+      return { workers: reportWorkers, health: reportHealth }
+    } else {
+      // update application heap
+      await this.#updateApplicationConfigHealth(applicationId, health)
+      // start new workers with new heap
+      const reportWorkers = await this.#updateApplicationWorkers(
+        applicationId,
+        config,
+        applicationConfig,
+        workers,
+        currentWorkers
+      )
+      // update heap for current workers
+      const reportHealth = await this.#updateApplicationHealth(
+        applicationId,
+        config,
+        applicationConfig,
+        currentWorkers,
+        currentHealth,
+        health,
+        false
+      )
 
-        message.raw = undefined
+      return { workers: reportWorkers, health: reportHealth }
+    }
+  }
+
+  async #updateApplicationHealth (
+    applicationId,
+    config,
+    applicationConfig,
+    currentWorkers,
+    currentHealth,
+    health,
+    updateConfig = true
+  ) {
+    const report = {
+      current: currentHealth,
+      new: health,
+      updated: []
+    }
+    try {
+      if (updateConfig) {
+        await this.#updateApplicationConfigHealth(applicationId, health)
       }
 
-      this.#loggerDestination.lastLevel = level
-      this.#loggerDestination.lastTime = time
-      this.#loggerDestination.lastMsg = msg
-      this.#loggerDestination.lastObj = message
-      this.#loggerDestination.lastLogger = this.logger
+      for (let i = 0; i < currentWorkers; i++) {
+        this.logger.info(
+          { health: { current: currentHealth, new: health } },
+          `Restarting application "${applicationId}" worker ${i} to update config health heap...`
+        )
 
-      // Never drop the `\n` as the worker thread trimmed the message
-      this.#loggerDestination.write(JSON.stringify(message) + '\n')
+        const worker = await this.#getWorkerById(applicationId, i)
+        if (health.maxHeapTotal) {
+          worker[kConfig].health.maxHeapTotal = health.maxHeapTotal
+        }
+        if (health.maxYoungGeneration) {
+          worker[kConfig].health.maxYoungGeneration = health.maxYoungGeneration
+        }
+
+        await this.#replaceWorker(config, applicationConfig, currentWorkers, applicationId, i, worker)
+        report.updated.push(i)
+        this.logger.info(
+          { health: { current: currentHealth, new: health } },
+          `Restarted application "${applicationId}" worker ${i}`
+        )
+      }
+      report.success = true
+    } catch (err) {
+      if (report.updated.length < 1) {
+        this.logger.error({ err }, 'Cannot update application health heap, no worker updated')
+        await this.#updateApplicationConfigHealth(applicationId, currentHealth)
+      } else {
+        this.logger.error(
+          { err },
+          `Cannot update application health heap, updated workers: ${report.updated.length} out of ${currentWorkers}`
+        )
+      }
+      report.success = false
     }
+    return report
   }
-}
 
-module.exports = { Runtime }
+  async #updateApplicationWorkers (applicationId, config, applicationConfig, workers, currentWorkers) {
+    const report = {
+      current: currentWorkers,
+      new: workers
+    }
+    if (currentWorkers < workers) {
+      report.started = []
+      try {
+        await this.#updateApplicationConfigWorkers(applicationId, workers)
+        for (let i = currentWorkers; i < workers; i++) {
+          await this.#setupWorker(config, applicationConfig, workers, applicationId, i)
+          await this.#startWorker(config, applicationConfig, workers, applicationId, i, false, 0)
+          report.started.push(i)
+        }
+        report.success = true
+      } catch (err) {
+        if (report.started.length < 1) {
+          this.logger.error({ err }, 'Cannot start application workers, no worker started')
+          await this.#updateApplicationConfigWorkers(applicationId, currentWorkers)
+        } else {
+          this.logger.error(
+            { err },
+            `Cannot start application workers, started workers: ${report.started.length} out of ${workers}`
+          )
+          await this.#updateApplicationConfigWorkers(applicationId, currentWorkers + report.started.length)
+        }
+        report.success = false
+      }
+    } else {
+      // keep the current workers count until all the application workers are all stopped
+      report.stopped = []
+      try {
+        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, [])
+          report.stopped.push(i)
+        }
+        await this.#updateApplicationConfigWorkers(applicationId, workers)
+        report.success = true
+      } catch (err) {
+        if (report.stopped.length < 1) {
+          this.logger.error({ err }, 'Cannot stop application workers, no worker stopped')
+        } else {
+          this.logger.error(
+            { err },
+            `Cannot stop application workers, stopped workers: ${report.stopped.length} out of ${workers}`
+          )
+          await this.#updateApplicationConfigWorkers(applicationId, currentWorkers - report.stopped)
+        }
+        report.success = false
+      }
+    }
+    return report
+  }
+
+  #validatePprofCapturePreload () {
+    const found = this.#config.preload?.some(p => p.includes('wattpm-pprof-capture'))
+
+    if (!found) {
+      throw new MissingPprofCapture()
+    }
+  }
+}