@platformatic/runtime 2.72.0 → 3.0.0-alpha.1

package/lib/runtime.js

@@ -1,27 +1,35 @@
 'use strict'
 
 const { ITC } = require('@platformatic/itc')
-const { features, ensureLoggableError, executeWithTimeout, deepmerge, parseMemorySize, kTimeout } = require('@platformatic/utils')
+const {
+  features,
+  ensureLoggableError,
+  executeWithTimeout,
+  deepmerge,
+  parseMemorySize,
+  kTimeout,
+  kMetadata
+} = require('@platformatic/utils')
 const { once, EventEmitter } = require('node:events')
 const { createReadStream, watch, existsSync } = require('node:fs')
 const { readdir, readFile, stat, access } = require('node:fs/promises')
 const { STATUS_CODES } = require('node:http')
 const { join } = require('node:path')
+const { pathToFileURL } = require('node:url')
 const { setTimeout: sleep, setImmediate: immediate } = require('node:timers/promises')
 const { Worker } = require('node:worker_threads')
 const ts = require('tail-file-stream')
 const { Agent, interceptors: undiciInterceptors, request } = require('undici')
 const { createThreadInterceptor } = require('undici-thread-interceptor')
 const SonicBoom = require('sonic-boom')
-
 const { checkDependencies, topologicalSort } = require('./dependencies')
 const errors = require('./errors')
-const { createLogger } = require('./logger')
+const { abstractLogger, createLogger } = require('./logger')
 const { startManagementApi } = require('./management-api')
 const { startPrometheusServer } = require('./prom-server')
 const { startScheduler } = require('./scheduler')
 const { createSharedStore } = require('./shared-http-cache')
-const { getRuntimeTmpDir } = require('./utils')
+const { getRuntimeTmpDir, getRuntimeLogsDir } = require('./utils')
 const { sendViaITC, waitEventFromITC } = require('./worker/itc')
 const { RoundRobinMap } = require('./worker/round-robin-map.js')
 const {
@@ -37,7 +45,6 @@ const {
   kLastELU,
   kWorkersBroadcast
 } = require('./worker/symbols')
-
 const fastify = require('fastify')
 
 const platformaticVersion = require('../package.json').version
@@ -58,11 +65,13 @@ const telemetryPath = require.resolve('@platformatic/telemetry')
 const openTelemetrySetupPath = join(telemetryPath, '..', 'lib', 'node-telemetry.js')
 
 class Runtime extends EventEmitter {
-  #configManager
+  #root
+  #config
+  #env
+  #context
   #isProduction
   #runtimeTmpDir
   #runtimeLogsDir
-  #env
   #servicesIds
   #entrypointId
   #url
@@ -83,29 +92,32 @@ class Runtime extends EventEmitter {
   servicesConfigsPatches
   #scheduler
   #stdio
-  #sharedContext
 
-  constructor (configManager, runtimeLogsDir, env) {
+  constructor (config, context) {
     super()
     this.setMaxListeners(MAX_LISTENERS_COUNT)
 
-    this.#configManager = configManager
-    this.#runtimeTmpDir = getRuntimeTmpDir(configManager.dirname)
-    this.#runtimeLogsDir = runtimeLogsDir
-    this.#env = env
+    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.#runtimeTmpDir = getRuntimeTmpDir(this.#root)
+    this.#runtimeLogsDir = getRuntimeLogsDir(this.#root, process.pid)
     this.#workers = new RoundRobinMap()
     this.#servicesIds = []
     this.#url = undefined
     this.#meshInterceptor = createThreadInterceptor({
       domain: '.plt.local',
-      timeout: this.#configManager.current.serviceTimeout
+      timeout: this.#config.serviceTimeout
     })
+    this.logger = abstractLogger // This is replaced by the real logger in init() and eventually removed in close()
     this.#status = undefined
     this.#restartingWorkers = new Map()
     this.#sharedHttpCache = null
     this.servicesConfigsPatches = new Map()
 
-    if (!this.#configManager.current.logger.captureStdio) {
+    if (!this.#config.logger.captureStdio) {
       this.#stdio = {
         stdout: new SonicBoom({ fd: process.stdout.fd }),
         stderr: new SonicBoom({ fd: process.stderr.fd })
@@ -121,22 +133,23 @@ class Runtime extends EventEmitter {
       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)
+      invalidateHttpCache: this.invalidateHttpCache.bind(this)
     }
-    this.#sharedContext = {}
   }
 
   async init () {
-    const config = this.#configManager.current
+    if (typeof this.#status !== 'undefined') {
+      return
+    }
+
+    const config = this.#config
     const autoloadEnabled = config.autoload
 
     // This cannot be transferred to worker threads
     delete config.configManager
 
     if (config.managementApi) {
-      this.#managementApi = await startManagementApi(this, this.#configManager)
+      this.#managementApi = await startManagementApi(this, this.#root)
     }
 
     if (config.metrics) {
@@ -148,13 +161,12 @@ class Runtime extends EventEmitter {
     this.logger = logger
     this.#loggerDestination = destination
 
-    this.#isProduction = this.#configManager.args?.production ?? false
     this.#servicesIds = config.services.map(service => service.id)
     this.#createWorkersBroadcastChannel()
 
     const workersConfig = []
     for (const service of config.services) {
-      const count = service.workers ?? this.#configManager.current.workers
+      const count = service.workers ?? this.#config.workers
       if (count > 1 && service.entrypoint && !features.node.reusePort) {
         this.logger.warn(
           `"${service.id}" is set as the entrypoint, but reusePort is not available in your OS; setting workers to 1 instead of ${count}`
@@ -181,7 +193,7 @@ class Runtime extends EventEmitter {
       if (!serviceConfig.path) {
         if (serviceConfig.url) {
           // Try to backfill the path for external services
-          serviceConfig.path = join(this.#configManager.dirname, config.resolvedServicesBasePath, serviceConfig.id)
+          serviceConfig.path = join(this.#root, config.resolvedServicesBasePath, serviceConfig.id)
 
           if (!existsSync(serviceConfig.path)) {
             const executable = globalThis.platformatic?.executable ?? 'platformatic'
@@ -244,7 +256,11 @@ class Runtime extends EventEmitter {
   }
 
   async start (silent = false) {
-    if (typeof this.#configManager.current.entrypoint === 'undefined') {
+    if (typeof this.#status === 'undefined') {
+      await this.init()
+    }
+
+    if (typeof this.#config.entrypoint === 'undefined') {
       throw new errors.MissingEntrypointError()
     }
     this.#updateStatus('starting')
@@ -256,16 +272,16 @@ class Runtime extends EventEmitter {
         await this.startService(service, silent)
       }
 
-      if (this.#configManager.current.inspectorOptions) {
-        const { port } = this.#configManager.current.inspectorOptions
+      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.#configManager.current.inspectorOptions.port + 1}/json/version`
-        ).then(res => res.json())
+        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 => {
@@ -375,9 +391,9 @@ class Runtime extends EventEmitter {
     }
 
     if (this.logger) {
-      this.#loggerDestination.end()
+      this.#loggerDestination?.end()
 
-      this.logger = null
+      this.logger = abstractLogger
       this.#loggerDestination = null
     }
 
@@ -406,7 +422,7 @@ class Runtime extends EventEmitter {
       throw new errors.ApplicationAlreadyStartedError()
     }
 
-    const config = this.#configManager.current
+    const config = this.#config
     const serviceConfig = config.services.find(s => s.id === id)
 
     if (!serviceConfig) {
@@ -425,7 +441,7 @@ class Runtime extends EventEmitter {
   }
 
   async stopService (id, silent = false) {
-    const config = this.#configManager.current
+    const config = this.#config
     const serviceConfig = config.services.find(s => s.id === id)
 
     if (!serviceConfig) {
@@ -506,7 +522,7 @@ class Runtime extends EventEmitter {
   }
 
   async updateUndiciInterceptors (undiciConfig) {
-    this.#configManager.current.undici = undiciConfig
+    this.#config.undici = undiciConfig
 
     const promises = []
     for (const worker of this.#workers.values()) {
@@ -635,6 +651,10 @@ class Runtime extends EventEmitter {
     this.on('closed', onClose)
   }
 
+  async getUrl () {
+    return this.#url
+  }
+
   async getRuntimeMetadata () {
     const packageJson = await this.#getRuntimePackageJson()
     const entrypointDetails = await this.getEntrypointDetails()
@@ -646,7 +666,7 @@ 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,
@@ -655,11 +675,16 @@ class Runtime extends EventEmitter {
   }
 
   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 () {
@@ -1082,46 +1107,18 @@ class Runtime extends EventEmitter {
       }
     }
 
+    this.logger.trace({ event, payload }, 'Runtime event')
     return super.emit(event, payload)
   }
 
-  async updateSharedContext (options = {}) {
-    const { context, overwrite = false } = options
-
-    const sharedContext = overwrite ? {} : this.#sharedContext
-    Object.assign(sharedContext, context)
-
-    this.#sharedContext = sharedContext
-
-    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')
-      }
-    }
-
-    return sharedContext
-  }
-
-  getSharedContext () {
-    return this.#sharedContext
-  }
-
   async #setDispatcher (undiciConfig) {
-    const config = this.#configManager.current
+    const config = this.#config
 
     const dispatcherOpts = { ...undiciConfig }
     const interceptors = [this.#meshInterceptor]
 
     if (config.httpCache) {
-      this.#sharedHttpCache = await createSharedStore(this.#configManager.dirname, config.httpCache)
+      this.#sharedHttpCache = await createSharedStore(this.#root, config.httpCache)
       interceptors.push(
         undiciInterceptors.cache({
           store: this.#sharedHttpCache,
@@ -1144,7 +1141,7 @@ class Runtime extends EventEmitter {
   async #setupService (serviceConfig) {
     if (this.#status === 'stopping' || this.#status === 'closed') return
 
-    const config = this.#configManager.current
+    const config = this.#config
     const workersCount = await this.#workers.getCount(serviceConfig.id)
     const id = serviceConfig.id
 
@@ -1162,9 +1159,9 @@ class Runtime extends EventEmitter {
     // Handle inspector
     let inspectorOptions
 
-    if (this.#configManager.current.inspectorOptions) {
+    if (this.#config.inspectorOptions) {
       inspectorOptions = {
-        ...this.#configManager.current.inspectorOptions
+        ...this.#config.inspectorOptions
       }
 
       inspectorOptions.port = inspectorOptions.port + this.#workers.size + 1
@@ -1183,11 +1180,12 @@ class Runtime extends EventEmitter {
 
     const execArgv = []
 
-    if (!serviceConfig.isPLTService && config.telemetry && config.telemetry.enabled !== false) {
+    if (!serviceConfig.skipTelemetryHooks && config.telemetry && config.telemetry.enabled !== false) {
+      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('--experimental-loader', '@opentelemetry/instrumentation/hook.mjs')
-      execArgv.push('--require', openTelemetrySetupPath)
+      execArgv.push('--import', `data:text/javascript, import { register } from 'node:module'; register('${hookUrl}')`)
+      execArgv.push('--import', pathToFileURL(openTelemetrySetupPath))
     }
 
     if ((serviceConfig.sourceMaps ?? config.sourceMaps) === true) {
@@ -1202,8 +1200,12 @@ class Runtime extends EventEmitter {
       workerEnv['NODE_OPTIONS'] = `${originalNodeOptions} ${serviceConfig.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 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)
@@ -1224,7 +1226,7 @@ class Runtime extends EventEmitter {
           count: workersCount
         },
         inspectorOptions,
-        dirname: this.#configManager.dirname,
+        dirname: this.#root,
         runtimeLogsDir: this.#runtimeLogsDir
       },
       argv: serviceConfig.arguments,
@@ -1300,7 +1302,7 @@ class Runtime extends EventEmitter {
       worker[kInspectorOptions] = {
         port: inspectorOptions.port,
         id: serviceId,
-        dirname: this.#configManager.dirname
+        dirname: this.#root
       }
     }
 
@@ -1317,10 +1319,15 @@ class Runtime extends EventEmitter {
     })
     worker[kITC].listen()
 
+    // Forward events from the worker
+    worker[kITC].on('event', ({ event, payload }) => {
+      this.emit(`service:worker:event:${event}`, { ...eventPayload, payload })
+    })
+
     // Only activate watch for the first instance
     if (index === 0) {
       // Handle services changes
-      // This is not purposely activated on when this.#configManager.current.watch === true
+      // This is not purposely activated on when this.#config.watch === true
       // so that services can eventually manually trigger a restart. This mechanism is current
       // used by the composer.
       worker[kITC].on('changed', async () => {
@@ -1334,13 +1341,14 @@ class Runtime extends EventEmitter {
             await this.startService(serviceId)
           }
 
-          this.logger?.info(`The service "${serviceId}" has been successfully reloaded ...`)
+          this.logger.info(`The service "${serviceId}" has been successfully reloaded ...`)
+          this.emit('service:worker:reloaded', eventPayload)
 
           if (serviceConfig.entrypoint) {
             this.#showUrl()
           }
         } catch (e) {
-          this.logger?.error(e)
+          this.logger.error(e)
         }
       })
     }
@@ -1379,9 +1387,7 @@ class Runtime extends EventEmitter {
     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
+      const elu = worker[kLastELU] ? worker.performance.eventLoopUtilization(currentELU, worker[kLastELU]) : currentELU
       worker[kLastELU] = currentELU
       return { elu: elu.utilization, heapUsed, heapTotal }
     }
@@ -1416,11 +1422,10 @@ class Runtime extends EventEmitter {
         health = { elu: -1, heapUsed: -1, heapTotal: -1 }
       }
 
-      const serviceId = worker[kServiceId]
-      this.emit('health', {
+      this.emit('service:worker:health', {
         id: worker[kId],
-        service: serviceId,
-        worker: worker[kWorkerId],
+        service: id,
+        worker: index,
         currentHealth: health,
         unhealthy,
         healthConfig: worker[kConfig].health
@@ -1446,6 +1451,8 @@ class Runtime extends EventEmitter {
 
       if (unhealthyChecks === maxUnhealthyChecks) {
         try {
+          this.emit('service:worker:unhealthy', { service: id, worker: index })
+
           this.logger.error(
             { elu: health.elu, maxELU, memoryUsage: health.heapUsed, maxMemoryUsage: maxHeapUsed },
             `The ${errorLabel} is unhealthy. Replacing it ...`
@@ -1480,7 +1487,7 @@ class Runtime extends EventEmitter {
     const label = this.#workerExtendedLabel(id, index, workersCount)
 
     if (!silent) {
-      this.logger?.info(`Starting the ${label}...`)
+      this.logger.info(`Starting the ${label}...`)
     }
 
     if (!worker) {
@@ -1524,14 +1531,23 @@ class Runtime extends EventEmitter {
       this.#broadcastWorkers()
 
       if (!silent) {
-        this.logger?.info(`Started the ${label}...`)
+        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
-        this.#setupHealthCheck(config, serviceConfig, workersCount, id, index, worker, label, gracePeriod > 0 ? gracePeriod : 1)
+        this.#setupHealthCheck(
+          config,
+          serviceConfig,
+          workersCount,
+          id,
+          index,
+          worker,
+          label,
+          gracePeriod > 0 ? gracePeriod : 1
+        )
       }
     } catch (error) {
       // TODO: handle port allocation error here
@@ -1593,15 +1609,16 @@ class Runtime extends EventEmitter {
     const eventPayload = { service: id, worker: index, workersCount }
 
     worker[kWorkerStatus] = 'stopping'
+    worker[kITC].removeAllListeners('changed')
     this.emit('service:worker:stopping', eventPayload)
 
     const label = this.#workerExtendedLabel(id, index, workersCount)
 
     if (!silent) {
-      this.logger?.info(`Stopping the ${label}...`)
+      this.logger.info(`Stopping the ${label}...`)
     }
 
-    const exitTimeout = this.#configManager.current.gracefulShutdown.runtime
+    const exitTimeout = this.#config.gracefulShutdown.runtime
     const exitPromise = once(worker, 'exit')
 
     // Always send the stop message, it will shut down workers that only had ITC and interceptors setup
@@ -1609,13 +1626,13 @@ class Runtime extends EventEmitter {
       await executeWithTimeout(sendViaITC(worker, 'stop'), exitTimeout)
     } catch (error) {
       this.emit('service:worker:stop:timeout', eventPayload)
-      this.logger?.info({ error: ensureLoggableError(error) }, `Failed to stop ${label}. Killing a worker thread.`)
+      this.logger.info({ error: ensureLoggableError(error) }, `Failed to stop ${label}. Killing a worker thread.`)
     } finally {
       worker[kITC].close()
     }
 
     if (!silent) {
-      this.logger?.info(`Stopped the ${label}...`)
+      this.logger.info(`Stopped the ${label}...`)
     }
 
     // Wait for the worker thread to finish, we're going to create a new one if the service is ever restarted
@@ -1819,11 +1836,7 @@ class Runtime extends EventEmitter {
       })
     }
 
-    try {
-      this.#workersBroadcastChannel.postMessage(workers)
-    } catch (err) {
-      this.logger?.error({ err }, 'Error when broadcasting workers')
-    }
+    this.#workersBroadcastChannel.postMessage(workers)
   }
 
   async #getWorkerMessagingChannel ({ service, worker }, context) {
@@ -1834,7 +1847,7 @@ class Runtime extends EventEmitter {
     // Send the first port to the target
     const response = await executeWithTimeout(
       sendViaITC(target, 'saveMessagingChannel', port1, [port1]),
-      this.#configManager.current.messagingTimeout
+      this.#config.messagingTimeout
     )
 
     if (response === kTimeout) {
@@ -1847,7 +1860,7 @@ class Runtime extends EventEmitter {
   }
 
   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)
@@ -1931,7 +1944,7 @@ class Runtime extends EventEmitter {
   // 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.#configManager.current.logger.captureStdio) {
+    if (!this.#config.logger.captureStdio) {
       this.#stdio[label].write(data)
       return
     }
@@ -2007,7 +2020,7 @@ class Runtime extends EventEmitter {
   async #updateServiceConfigWorkers (serviceId, workers) {
     this.logger.info(`Updating service "${serviceId}" config workers to ${workers}`)
 
-    this.#configManager.current.services.find(s => s.id === serviceId).workers = workers
+    this.#config.services.find(s => s.id === serviceId).workers = workers
     const service = await this.#getServiceById(serviceId)
     this.#workers.setCount(serviceId, workers)
     service[kConfig].workers = workers
@@ -2032,7 +2045,7 @@ class Runtime extends EventEmitter {
     this.logger.info(`Updating service "${serviceId}" config health heap to ${JSON.stringify(health)}`)
     const { maxHeapTotal, maxYoungGeneration } = health
 
-    const service = this.#configManager.current.services.find(s => s.id === serviceId)
+    const service = this.#config.services.find(s => s.id === serviceId)
     if (maxHeapTotal) {
       service.health.maxHeapTotal = maxHeapTotal
     }
@@ -2093,21 +2106,36 @@ class Runtime extends EventEmitter {
     }
 
     const ups = await this.#validateUpdateServiceResources(updates)
-    const config = this.#configManager.current
+    const config = this.#config
 
     const report = []
     for (const update of ups) {
       const { serviceId, config: serviceConfig, workers, health, currentWorkers, currentHealth } = update
 
       if (workers && health) {
-        const r = await this.#updateServiceWorkersAndHealth(serviceId, config, serviceConfig, workers, health, currentWorkers, currentHealth)
+        const r = await this.#updateServiceWorkersAndHealth(
+          serviceId,
+          config,
+          serviceConfig,
+          workers,
+          health,
+          currentWorkers,
+          currentHealth
+        )
         report.push({
           service: serviceId,
           workers: r.workers,
           health: r.health
         })
       } else if (health) {
-        const r = await this.#updateServiceHealth(serviceId, config, serviceConfig, currentWorkers, currentHealth, health)
+        const r = await this.#updateServiceHealth(
+          serviceId,
+          config,
+          serviceConfig,
+          currentWorkers,
+          currentHealth,
+          health
+        )
         report.push({
           service: serviceId,
           health: r.health
@@ -2132,7 +2160,7 @@ class Runtime extends EventEmitter {
       throw new errors.InvalidArgumentError('updates', 'must have at least one element')
     }
 
-    const config = this.#configManager.current
+    const config = this.#config
     const validatedUpdates = []
     for (const update of updates) {
       const { service: serviceId } = update
@@ -2181,7 +2209,10 @@ class Runtime extends EventEmitter {
               throw new errors.InvalidArgumentError('maxHeapTotal', 'must be greater than 0')
             }
           } else {
-            throw new errors.InvalidArgumentError('maxHeapTotal', 'must be a number or a string representing a memory size')
+            throw new errors.InvalidArgumentError(
+              'maxHeapTotal',
+              'must be a number or a string representing a memory size'
+            )
           }
 
           if (currentHealth.maxHeapTotal === maxHeapTotal) {
@@ -2203,7 +2234,10 @@ class Runtime extends EventEmitter {
               throw new errors.InvalidArgumentError('maxYoungGeneration', 'must be greater than 0')
             }
           } else {
-            throw new errors.InvalidArgumentError('maxYoungGeneration', 'must be a number or a string representing a memory size')
+            throw new errors.InvalidArgumentError(
+              'maxYoungGeneration',
+              'must be a number or a string representing a memory size'
+            )
           }
 
           if (currentHealth.maxYoungGeneration && currentHealth.maxYoungGeneration === maxYoungGeneration) {
@@ -2216,7 +2250,7 @@ class Runtime extends EventEmitter {
       if (workers || maxHeapTotal || maxYoungGeneration) {
         let health
         if (maxHeapTotal || maxYoungGeneration) {
-          health = { }
+          health = {}
           if (maxHeapTotal) {
             health.maxHeapTotal = maxHeapTotal
           }
@@ -2231,12 +2265,27 @@ class Runtime extends EventEmitter {
     return validatedUpdates
   }
 
-  async #updateServiceWorkersAndHealth (serviceId, config, serviceConfig, workers, health, currentWorkers, currentHealth) {
+  async #updateServiceWorkersAndHealth (
+    serviceId,
+    config,
+    serviceConfig,
+    workers,
+    health,
+    currentWorkers,
+    currentHealth
+  ) {
     if (currentWorkers > workers) {
       // stop workers
       const reportWorkers = await this.#updateServiceWorkers(serviceId, config, serviceConfig, workers, currentWorkers)
       // update heap for current workers
-      const reportHealth = await this.#updateServiceHealth(serviceId, config, serviceConfig, workers, currentHealth, health)
+      const reportHealth = await this.#updateServiceHealth(
+        serviceId,
+        config,
+        serviceConfig,
+        workers,
+        currentHealth,
+        health
+      )
 
       return { workers: reportWorkers, health: reportHealth }
     } else {
@@ -2245,13 +2294,29 @@ class Runtime extends EventEmitter {
       // start new workers with new heap
       const reportWorkers = await this.#updateServiceWorkers(serviceId, config, serviceConfig, workers, currentWorkers)
       // update heap for current workers
-      const reportHealth = await this.#updateServiceHealth(serviceId, config, serviceConfig, currentWorkers, currentHealth, health, false)
+      const reportHealth = await this.#updateServiceHealth(
+        serviceId,
+        config,
+        serviceConfig,
+        currentWorkers,
+        currentHealth,
+        health,
+        false
+      )
 
       return { workers: reportWorkers, health: reportHealth }
     }
   }
 
-  async #updateServiceHealth (serviceId, config, serviceConfig, currentWorkers, currentHealth, health, updateConfig = true) {
+  async #updateServiceHealth (
+    serviceId,
+    config,
+    serviceConfig,
+    currentWorkers,
+    currentHealth,
+    health,
+    updateConfig = true
+  ) {
     const report = {
       current: currentHealth,
       new: health,
@@ -2263,15 +2328,25 @@ class Runtime extends EventEmitter {
       }
 
       for (let i = 0; i < currentWorkers; i++) {
-        this.logger.info({ health: { current: currentHealth, new: health } }, `Restarting service "${serviceId}" worker ${i} to update config health heap...`)
+        this.logger.info(
+          { health: { current: currentHealth, new: health } },
+          `Restarting service "${serviceId}" worker ${i} to update config health heap...`
+        )
 
         const worker = await this.#getWorkerById(serviceId, i)
-        if (health.maxHeapTotal) { worker[kConfig].health.maxHeapTotal = health.maxHeapTotal }
-        if (health.maxYoungGeneration) { worker[kConfig].health.maxYoungGeneration = health.maxYoungGeneration }
+        if (health.maxHeapTotal) {
+          worker[kConfig].health.maxHeapTotal = health.maxHeapTotal
+        }
+        if (health.maxYoungGeneration) {
+          worker[kConfig].health.maxYoungGeneration = health.maxYoungGeneration
+        }
 
         await this.#replaceWorker(config, serviceConfig, currentWorkers, serviceId, i, worker)
         report.updated.push(i)
-        this.logger.info({ health: { current: currentHealth, new: health } }, `Restarted service "${serviceId}" worker ${i}`)
+        this.logger.info(
+          { health: { current: currentHealth, new: health } },
+          `Restarted service "${serviceId}" worker ${i}`
+        )
       }
       report.success = true
     } catch (err) {
@@ -2279,7 +2354,10 @@ class Runtime extends EventEmitter {
         this.logger.error({ err }, 'Cannot update service health heap, no worker updated')
         await this.#updateServiceConfigHealth(serviceId, currentHealth)
       } else {
-        this.logger.error({ err }, `Cannot update service health heap, updated workers: ${report.updated.length} out of ${currentWorkers}`)
+        this.logger.error(
+          { err },
+          `Cannot update service health heap, updated workers: ${report.updated.length} out of ${currentWorkers}`
+        )
       }
       report.success = false
     }
@@ -2306,7 +2384,10 @@ class Runtime extends EventEmitter {
           this.logger.error({ err }, 'Cannot start service workers, no worker started')
           await this.#updateServiceConfigWorkers(serviceId, currentWorkers)
         } else {
-          this.logger.error({ err }, `Cannot start service workers, started workers: ${report.started.length} out of ${workers}`)
+          this.logger.error(
+            { err },
+            `Cannot start service workers, started workers: ${report.started.length} out of ${workers}`
+          )
           await this.#updateServiceConfigWorkers(serviceId, currentWorkers + report.started.length)
         }
         report.success = false
@@ -2327,7 +2408,10 @@ class Runtime extends EventEmitter {
         if (report.stopped.length < 1) {
           this.logger.error({ err }, 'Cannot stop service workers, no worker stopped')
         } else {
-          this.logger.error({ err }, `Cannot stop service workers, stopped workers: ${report.stopped.length} out of ${workers}`)
+          this.logger.error(
+            { err },
+            `Cannot stop service workers, stopped workers: ${report.stopped.length} out of ${workers}`
+          )
           await this.#updateServiceConfigWorkers(serviceId, currentWorkers - report.stopped)
         }
         report.success = false