@platformatic/runtime 3.57.0 → 3.58.1

package/config.d.ts

@@ -221,7 +221,7 @@ export type PlatformaticRuntimeConfig = {
   reuseTcpPorts?: boolean;
   startTimeout?: number;
   restartOnError?: boolean | number;
-  exitOnUnhandledErrors?: boolean;
+  exitOnUnhandledErrors?: boolean | number;
   gracefulShutdown?: {
     runtime: number | string;
     application: number | string;
@@ -243,6 +243,7 @@ export type PlatformaticRuntimeConfig = {
     bufferPoolSize?: number | string;
     defaultHighWaterMark?: number | string;
   };
+  healthProbes?: boolean | string;
   undici?: {
     agentOptions?: {
       [k: string]: unknown;

package/lib/generator.js

@@ -268,8 +268,9 @@ export class RuntimeGenerator extends BaseGenerator {
       this.questions.push({
         type: 'input',
         name: 'port',
-        default: 3042,
-        message: 'What port do you want to use?'
+        default: '3042',
+        message: 'What port do you want to use?',
+        filter: Number
       })
     }
   }

package/lib/logger.js

@@ -1,4 +1,7 @@
-import { buildPinoFormatters, buildPinoTimestamp } from '@platformatic/foundation'
+import {
+  buildPinoFormatters,
+  buildPinoTimestamp,
+} from '@platformatic/foundation'
 import { isatty } from 'node:tty'
 import pino from 'pino'
 import pretty from 'pino-pretty'
@@ -158,6 +161,12 @@ export async function createLogger (config) {
   let cliStream
 
   if (config.logger.transport) {
+    if (Array.isArray(config.logger.transport.targets)) {
+      for (const target of config.logger.transport.targets) {
+        target.level ??= config.logger.level
+      }
+    }
+
     cliStream = pino.transport(config.logger.transport)
   } else if ((process.env.FORCE_TTY || isatty(1)) && process.env.PLT_PRETTY_PRINT !== 'false') {
     cliStream = createPrettifier(context)

package/lib/prom-server.js

@@ -1,8 +1,7 @@
 import fastifyAccepts from '@fastify/accepts'
 import fastifyBasicAuth from '@fastify/basic-auth'
-import { loadModule } from '@platformatic/foundation'
+import { loadModule, sanitizeHTTPSOptions } from '@platformatic/foundation'
 import fastify from 'fastify'
-import { readFile } from 'node:fs/promises'
 import { createRequire } from 'node:module'
 import { resolve } from 'node:path'
 
@@ -53,33 +52,6 @@ async function checkReadiness (runtime) {
   return { response, status }
 }
 
-async function sanitizeHTTPSArgument (arg) {
-  if (typeof arg === 'string') {
-    return arg
-  } else if (!Array.isArray(arg)) {
-    return readFile(arg.path)
-  }
-
-  const sanitized = []
-  for (const item of arg) {
-    sanitized.push(typeof item === 'string' ? item : await readFile(item.path))
-  }
-
-  return sanitized
-}
-
-async function sanitizeHTTPSOptions (https) {
-  if (!https) {
-    return
-  }
-
-  return {
-    ...https,
-    key: await sanitizeHTTPSArgument(https.key),
-    cert: await sanitizeHTTPSArgument(https.cert)
-  }
-}
-
 async function checkLiveness (runtime) {
   const { status: ready, response: readinessResponse } = await checkReadiness(runtime)
   if (!ready) {
@@ -104,8 +76,11 @@ async function checkLiveness (runtime) {
   return { response, status }
 }
 
-export async function startPrometheusServer (runtime, opts) {
-  if (opts.enabled === false) {
+export async function startPrometheusServer (runtime, opts, healthProbes) {
+  const metricsEnabled = opts.enabled !== false
+  const healthProbesEnabled = healthProbes !== false
+
+  if (!metricsEnabled && !healthProbesEnabled) {
     return
   }
   const host = opts.hostname ?? DEFAULT_HOSTNAME
@@ -141,13 +116,17 @@ export async function startPrometheusServer (runtime, opts) {
     logLevel: 'warn',
     handler (req, reply) {
       reply.type('text/plain')
-      let response = `Hello from Platformatic Prometheus Server!\nThe metrics are available at ${metricsEndpoint}.`
+      let response = 'Hello from Platformatic Prometheus Server!'
 
-      if (opts.readiness !== false) {
+      if (metricsEnabled) {
+        response += `\nThe metrics are available at ${metricsEndpoint}.`
+      }
+
+      if (healthProbesEnabled && opts.readiness !== false) {
         response += `\nThe readiness endpoint is available at ${readinessEndpoint}.`
       }
 
-      if (opts.liveness !== false) {
+      if (healthProbesEnabled && opts.liveness !== false) {
         response += `\nThe liveness endpoint is available at ${livenessEndpoint}.`
       }
 
@@ -155,22 +134,24 @@ export async function startPrometheusServer (runtime, opts) {
     }
   })
 
-  promServer.route({
-    url: metricsEndpoint,
-    method: 'GET',
-    logLevel: 'warn',
-    onRequest: onRequestHook,
-    handler: async (req, reply) => {
-      const accepts = req.accepts()
-      const reqType = !accepts.type('text/plain') && accepts.type('application/json') ? 'json' : 'text'
-      if (reqType === 'text') {
-        reply.type('text/plain')
+  if (metricsEnabled) {
+    promServer.route({
+      url: metricsEndpoint,
+      method: 'GET',
+      logLevel: 'warn',
+      onRequest: onRequestHook,
+      handler: async (req, reply) => {
+        const accepts = req.accepts()
+        const reqType = !accepts.type('text/plain') && accepts.type('application/json') ? 'json' : 'text'
+        if (reqType === 'text') {
+          reply.type('text/plain')
+        }
+        return (await runtime.getMetrics(reqType)).metrics
       }
-      return (await runtime.getMetrics(reqType)).metrics
-    }
-  })
+    })
+  }
 
-  if (opts.readiness !== false) {
+  if (healthProbesEnabled && opts.readiness !== false) {
     const successStatusCode = opts.readiness?.success?.statusCode ?? DEFAULT_READINESS_SUCCESS_STATUS_CODE
     const successBody = opts.readiness?.success?.body ?? DEFAULT_READINESS_SUCCESS_BODY
     const failStatusCode = opts.readiness?.fail?.statusCode ?? DEFAULT_READINESS_FAIL_STATUS_CODE
@@ -209,7 +190,7 @@ export async function startPrometheusServer (runtime, opts) {
     })
   }
 
-  if (opts.liveness !== false) {
+  if (healthProbesEnabled && opts.liveness !== false) {
     const successStatusCode = opts.liveness?.success?.statusCode ?? DEFAULT_LIVENESS_SUCCESS_STATUS_CODE
     const successBody = opts.liveness?.success?.body ?? DEFAULT_LIVENESS_SUCCESS_BODY
     const failStatusCode = opts.liveness?.fail?.statusCode ?? DEFAULT_LIVENESS_FAIL_STATUS_CODE

package/lib/runtime.js

@@ -143,6 +143,7 @@ export class Runtime extends EventEmitter {
   #restartingApplications
   #restartingWorkers
   #dynamicWorkersScaler
+  #nextWorkerIndex
 
   #sharedHttpCache
   #scheduler
@@ -178,6 +179,7 @@ export class Runtime extends EventEmitter {
     this.#status = undefined
     this.#restartingApplications = new Set()
     this.#restartingWorkers = new Map()
+    this.#nextWorkerIndex = new Map()
     this.#sharedHttpCache = null
     this.#applicationsConfigsPatches = new Map()
 
@@ -227,7 +229,7 @@ export class Runtime extends EventEmitter {
     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)
+      this.#prometheusServer = await startPrometheusServer(this, config.metrics, config.healthProbes)
     } else {
       // Default to applicationId if metrics are not configured
       this.#metricsLabelName = 'applicationId'
@@ -578,10 +580,10 @@ export class Runtime extends EventEmitter {
   }
 
   async startApplications (applications, silent = false) {
-    // For each worker, get its dependencies from the first worker
+    // For each application, get its dependencies from any available worker.
     const dependencies = new Map()
     for (const applicationId of applications) {
-      const worker = await this.#getWorkerByIdOrNext(applicationId, 0)
+      const worker = await this.#getWorkerByIdOrNext(applicationId)
 
       dependencies.set(applicationId, await sendViaITC(worker, 'getDependencies'))
     }
@@ -728,12 +730,13 @@ export class Runtime extends EventEmitter {
       for (let i = 0; i < workersCount; i++) {
         const workerId = workersIds[i]
         const worker = this.#workers.get(workerId)
+        const workerIndex = parseInt(workerId.split(':')[1], 10)
 
         if (i > 0 && config.workersRestartDelay > 0) {
           await sleep(config.workersRestartDelay)
         }
 
-        await this.#replaceWorker(config, applicationConfig, workersCount, id, i, worker, true)
+        await this.#replaceWorker(config, applicationConfig, workersCount, id, workerIndex, worker, true)
       }
 
       this.#incrementApplicationRestartCount(id)
@@ -855,8 +858,8 @@ export class Runtime extends EventEmitter {
     this.#config.metrics = metricsConfig
     this.#metricsLabelName = metricsConfig?.applicationLabel || 'applicationId'
 
-    if (metricsConfig.enabled !== false) {
-      this.#prometheusServer = await startPrometheusServer(this, metricsConfig)
+    if (metricsConfig.enabled !== false || this.#config.healthProbes !== false) {
+      this.#prometheusServer = await startPrometheusServer(this, metricsConfig, this.#config.healthProbes)
     }
 
     const promises = []
@@ -1491,7 +1494,8 @@ export class Runtime extends EventEmitter {
 
   async getApplicationResourcesInfo (id) {
     const workersCount = this.#workers.getKeys(id).length
-    const worker = await this.#getWorkerByIdOrNext(id, 0, false, false)
+    // Use round-robin to get any available worker instead of assuming index 0 exists
+    const worker = await this.#getWorkerByIdOrNext(id, null, false, false)
     const health = worker[kConfig].health
 
     return { workers: workersCount, health }
@@ -1779,6 +1783,9 @@ export class Runtime extends EventEmitter {
 
     await executeInParallel(this.#setupWorker.bind(this), setupInvocations, this.#concurrency)
 
+    // Initialize the next worker index counter (next index starts after initial workers)
+    this.#nextWorkerIndex.set(id, workers)
+
     await this.#dynamicWorkersScaler?.add(applicationConfig)
     this.emitAndNotify('application:init', id)
   }
@@ -2025,8 +2032,9 @@ export class Runtime extends EventEmitter {
       }
     })
 
-    // Only activate watch for the first instance
-    if (index === 0) {
+    // Only activate watch for the first instance. Replacement workers get unique
+    // indices, so preserve the listener when replacing a single-worker app.
+    if (index === 0 || workersCount === 1) {
       // 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
@@ -2556,10 +2564,17 @@ export class Runtime extends EventEmitter {
     return `worker ${workerId} of the application "${applicationId}"`
   }
 
-  async #restartCrashedWorker (config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt) {
-    const workerId = `${id}:${index}`
+  #getNextWorkerIndex (applicationId) {
+    const index = this.#nextWorkerIndex.get(applicationId) ?? 0
+    this.#nextWorkerIndex.set(applicationId, index + 1)
+    return index
+  }
+
+  async #restartCrashedWorker (config, applicationConfig, workersCount, id, oldIndex, silent, bootstrapAttempt) {
+    // Use oldIndex for tracking to prevent duplicate restarts of the same crashed worker
+    const restartKey = `${id}:${oldIndex}`
 
-    let restartPromise = this.#restartingWorkers.get(workerId)
+    let restartPromise = this.#restartingWorkers.get(restartKey)
     if (restartPromise) {
       await restartPromise
       return
@@ -2567,7 +2582,7 @@ export class Runtime extends EventEmitter {
 
     restartPromise = new Promise((resolve, reject) => {
       async function restart () {
-        this.#restartingWorkers.delete(workerId)
+        this.#restartingWorkers.delete(restartKey)
 
         // If some processes were scheduled to restart
         // but the runtime is stopped, ignore it
@@ -2575,6 +2590,9 @@ export class Runtime extends EventEmitter {
           return
         }
 
+        // Get a new unique index for the restarted worker
+        const index = this.#getNextWorkerIndex(id)
+
         try {
           await this.#setupWorker(config, applicationConfig, workersCount, id, index)
           await this.#startWorker(config, applicationConfig, workersCount, id, index, silent, bootstrapAttempt)
@@ -2601,15 +2619,19 @@ export class Runtime extends EventEmitter {
       }
     })
 
-    this.#restartingWorkers.set(workerId, restartPromise)
+    this.#restartingWorkers.set(restartKey, restartPromise)
     await restartPromise
   }
 
-  async #replaceWorker (config, applicationConfig, workersCount, applicationId, index, worker, silent) {
-    const workerId = `${applicationId}:${index}`
-    const label = this.#workerExtendedLabel(applicationId, index, workersCount)
+  async #replaceWorker (config, applicationConfig, workersCount, applicationId, oldIndex, worker, silent) {
+    const oldLabel = this.#workerExtendedLabel(applicationId, oldIndex, workersCount)
     let newWorker
 
+    // Get a new unique index for the replacement worker
+    const newIndex = this.#getNextWorkerIndex(applicationId)
+    const newWorkerId = `${applicationId}:${newIndex}`
+    const newLabel = this.#workerExtendedLabel(applicationId, newIndex, workersCount)
+
     const stopBeforeStart =
       applicationConfig.entrypoint &&
       (config.reuseTcpPorts === false || applicationConfig.reuseTcpPorts === false || !features.node.reusePort)
@@ -2625,16 +2647,16 @@ export class Runtime extends EventEmitter {
     }
 
     if (stopBeforeStart) {
-      await this.#removeWorker(workersCount, applicationId, index, worker, silent, label)
+      await this.#removeWorker(workersCount, applicationId, oldIndex, worker, silent, oldLabel)
     }
 
     try {
       if (!silent) {
-        this.logger.debug(`Preparing to start a replacement for ${label}  ...`)
+        this.logger.debug(`Preparing to start ${newLabel} as replacement for ${oldLabel} ...`)
       }
 
-      // Create a new worker (use configForNewWorker which may have a pinned port for stopBeforeStart)
-      newWorker = await this.#setupWorker(configForNewWorker, applicationConfig, workersCount, applicationId, index, false)
+      // Create a new worker with a new index, preserving any pinned port when stopBeforeStart is required.
+      newWorker = await this.#setupWorker(configForNewWorker, applicationConfig, workersCount, applicationId, newIndex, false)
 
       // Make sure the runtime hasn't been stopped in the meanwhile
       if (this.#status !== 'started') {
@@ -2642,21 +2664,21 @@ export class Runtime extends EventEmitter {
       }
 
       // Add the worker to the mesh
-      await this.#startWorker(configForNewWorker, applicationConfig, workersCount, applicationId, index, false, 0, newWorker, true)
+      await this.#startWorker(configForNewWorker, applicationConfig, workersCount, applicationId, newIndex, 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.#workers.set(newWorkerId, newWorker)
     } catch (e) {
       newWorker?.terminate?.()
       throw e
     }
 
     if (!stopBeforeStart) {
-      await this.#removeWorker(workersCount, applicationId, index, worker, silent, label)
+      await this.#removeWorker(workersCount, applicationId, oldIndex, worker, silent, oldLabel)
     }
   }
 
@@ -3145,13 +3167,16 @@ export class Runtime extends EventEmitter {
         await this.#updateApplicationConfigHealth(applicationId, health)
       }
 
-      for (let i = 0; i < currentWorkers; i++) {
+      // Get actual worker keys to iterate over existing workers (snapshot to avoid mutation during iteration)
+      const workerKeys = [...this.#workers.getKeys(applicationId)]
+      for (const workerKey of workerKeys) {
+        const workerIndex = parseInt(workerKey.split(':')[1], 10)
         this.logger.info(
           { health: { current: currentHealth, new: health } },
-          `Restarting application "${applicationId}" worker ${i} to update config health heap...`
+          `Restarting application "${applicationId}" worker ${workerIndex} to update config health heap...`
         )
 
-        const worker = await this.#getWorkerByIdOrNext(applicationId, i)
+        const worker = this.#workers.get(workerKey)
         if (health.maxHeapTotal) {
           worker[kConfig].health.maxHeapTotal = health.maxHeapTotal
         }
@@ -3159,11 +3184,11 @@ export class Runtime extends EventEmitter {
           worker[kConfig].health.maxYoungGeneration = health.maxYoungGeneration
         }
 
-        await this.#replaceWorker(config, applicationConfig, currentWorkers, applicationId, i, worker)
-        report.updated.push(i)
+        await this.#replaceWorker(config, applicationConfig, currentWorkers, applicationId, workerIndex, worker)
+        report.updated.push(workerIndex)
         this.logger.info(
           { health: { current: currentHealth, new: health } },
-          `Restarted application "${applicationId}" worker ${i}`
+          `Restarted application "${applicationId}" worker ${workerIndex}`
         )
       }
       report.success = true
@@ -3196,9 +3221,10 @@ export class Runtime extends EventEmitter {
       report.started = []
       try {
         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)
+          const newIndex = this.#getNextWorkerIndex(applicationId)
+          await this.#setupWorker(config, applicationConfig, workers, applicationId, newIndex)
+          await this.#startWorker(config, applicationConfig, workers, applicationId, newIndex, false, 0)
+          report.started.push(newIndex)
           startedWorkersCount++
         }
         report.success = true
@@ -3217,11 +3243,19 @@ export class Runtime extends EventEmitter {
       // 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.#getWorkerByIdOrNext(applicationId, i, false, false)
+        // Get actual worker keys and sort by index descending to stop most recent first (snapshot to avoid mutation during iteration)
+        const workerKeys = [...this.#workers.getKeys(applicationId)]
+        const workerIndices = workerKeys
+          .map(key => parseInt(key.split(':')[1], 10))
+          .sort((a, b) => b - a) // descending order
+
+        const workersToStop = currentWorkers - workers
+        for (let i = 0; i < workersToStop && i < workerIndices.length; i++) {
+          const workerIndex = workerIndices[i]
+          const worker = this.#workers.get(`${applicationId}:${workerIndex}`)
           await sendViaITC(worker, 'removeFromMesh')
-          await this.#stopWorker(currentWorkers, applicationId, i, false, worker, [])
-          report.stopped.push(i)
+          await this.#stopWorker(currentWorkers, applicationId, workerIndex, false, worker, [])
+          report.stopped.push(workerIndex)
           stoppedWorkersCount++
         }
         report.success = true

package/lib/worker/controller.js

@@ -1,6 +1,5 @@
 import {
   ensureLoggableError,
-  executeWithTimeout,
   FileWatcher,
   kHandledError,
   listRecognizedConfigurationFiles,
@@ -37,17 +36,24 @@ function fetchApplicationUrl (application, key) {
   return getApplicationUrl(application.id)
 }
 
-function handleUnhandled (app, type, err) {
+function handleUnhandled (app, event, listeners, timeout, err, ...args) {
   const label = `worker ${workerData.worker.index} of the application "${workerData.applicationConfig.id}"`
 
   const logger = getLogger()
-  logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${type}.`)
+  logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${event} event.`)
 
-  executeWithTimeout(app?.stop(), 1000)
-    .catch()
-    .finally(() => {
-      process.exit(1)
-    })
+  // Give some time to the listeners, logger and ITC notifications to land before shutting down
+  setTimeout(() => process.exit(1), timeout)
+
+  for (const listener of listeners) {
+    try {
+      listener(err, ...args)
+    } catch (err) {
+      logger.error({ err: ensureLoggableError(err) }, `${event} error listener failed.`)
+    }
+  }
+
+  app.stop().catch()
 }
 
 export class Controller extends EventEmitter {
@@ -74,6 +80,8 @@ export class Controller extends EventEmitter {
 
     this.#context = {
       controller: this,
+      runtimeConfig: this.runtimeConfig,
+      applicationConfig: this.applicationConfig,
       applicationId: this.applicationId,
       workerId: this.workerId,
       directory: this.applicationConfig.path,
@@ -149,16 +157,19 @@ export class Controller extends EventEmitter {
         cleanupHandlers()
       }
 
-      if (this.capability.exitOnUnhandledErrors && this.runtimeConfig.exitOnUnhandledErrors) {
-        this.#setupHandlers()
+      let exitOnUnhandledErrors = this.runtimeConfig.exitOnUnhandledErrors
+
+      if (exitOnUnhandledErrors === true || typeof exitOnUnhandledErrors === 'undefined') {
+        exitOnUnhandledErrors = 100
+      }
+
+      if (typeof exitOnUnhandledErrors === 'number' && exitOnUnhandledErrors > 0) {
+        this.#setupHandlers(exitOnUnhandledErrors)
       }
     } catch (err) {
       if (err.validationErrors) {
         const logger = getLogger()
-        logger.error(
-          { err: ensureLoggableError(err) },
-          'The application threw a validation error.'
-        )
+        logger.error({ err: ensureLoggableError(err) }, 'The application threw a validation error.')
 
         throw err
       } else {
@@ -361,16 +372,25 @@ export class Controller extends EventEmitter {
     mirrorGlobalDispatcherForBuiltinFetch(dispatcher)
   }
 
-  #setupHandlers () {
-    process.on('uncaughtException', handleUnhandled.bind(null, this, 'uncaught exception'))
-    process.on('unhandledRejection', handleUnhandled.bind(null, this, 'unhandled rejection'))
+  #setupHandlers (timeout) {
+    const unhandledListeners = { uncaughtException: [], unhandledRejection: [] }
+
+    process.on(
+      'uncaughtException',
+      handleUnhandled.bind(null, this, 'uncaughtException', unhandledListeners.uncaughtException, timeout)
+    )
+    process.on(
+      'unhandledRejection',
+      handleUnhandled.bind(null, this, 'unhandledRejection', unhandledListeners.unhandledRejection, timeout)
+    )
 
-    process.on('newListener', event => {
+    process.on('newListener', (event, listener) => {
       if (event === 'uncaughtException' || event === 'unhandledRejection') {
-        const logger = getLogger()
-        logger.warn(
-          `A listener has been added for the "process.${event}" event. This listener will be never triggered as Watt default behavior will kill the process before.\n To disable this behavior, set "exitOnUnhandledErrors" to false in the runtime config.`
-        )
+        unhandledListeners[event].push(listener)
+
+        process.nextTick(() => {
+          process.removeListener(event, listener)
+        })
       }
     })
   }

package/lib/worker/main.js

@@ -28,14 +28,12 @@ import { setupITC } from './itc.js'
 import { SharedContext } from './shared-context.js'
 import { kStderrMarker } from './symbols.js'
 
-function handlePreInitializationUnhandled (type, err) {
+function handlePreInitializationUnhandled (type, timeout, err) {
   const label = `worker ${workerData.worker.index} of the application "${workerData.applicationConfig.id}"`
   const logger = getLogger()
-  logger.error(
-    { err: ensureLoggableError(err) },
-    `The ${label} threw an ${type} before initialization.`
-  )
-  process.exit(exitCodes.PROCESS_UNHANDLED_ERROR)
+  logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${type} before initialization.`)
+
+  setTimeout(() => process.exit(exitCodes.PROCESS_UNHANDLED_ERROR), timeout)
 }
 
 class ForwardingEventEmitter extends EventEmitter {
@@ -68,9 +66,9 @@ function patchLogging () {
   }
 }
 
-function setupHandlers () {
-  const unhandledExceptionHandler = handlePreInitializationUnhandled.bind(null, 'uncaught exception')
-  const unhandledRejectionHandler = handlePreInitializationUnhandled.bind(null, 'uncaught rejection')
+function setupHandlers (timeout) {
+  const unhandledExceptionHandler = handlePreInitializationUnhandled.bind(null, 'uncaught exception', timeout)
+  const unhandledRejectionHandler = handlePreInitializationUnhandled.bind(null, 'uncaught rejection', timeout)
   process.on('uncaughtException', unhandledExceptionHandler)
   process.on('unhandledRejection', unhandledRejectionHandler)
 
@@ -201,7 +199,16 @@ async function setupCompileCache (runtimeConfig, applicationConfig, logger) {
 }
 
 async function main () {
-  const cleanup = setupHandlers()
+  let cleanup = null
+  let exitOnUnhandledErrors = workerData.config.exitOnUnhandledErrors
+
+  if (exitOnUnhandledErrors === true || typeof exitOnUnhandledErrors === 'undefined') {
+    exitOnUnhandledErrors = 100
+  }
+
+  if (typeof exitOnUnhandledErrors === 'number' && exitOnUnhandledErrors > 0) {
+    cleanup = setupHandlers(exitOnUnhandledErrors)
+  }
 
   installUndiciGlobals(globalThis)
   updateGlobals({
@@ -319,15 +326,14 @@ async function main () {
 
   // Setup management client for privileged applications
   if (applicationConfig.management) {
-    const mgmtEnabled = typeof applicationConfig.management === 'boolean'
-      ? applicationConfig.management
-      : applicationConfig.management.enabled !== false
+    const mgmtEnabled =
+      typeof applicationConfig.management === 'boolean'
+        ? applicationConfig.management
+        : applicationConfig.management.enabled !== false
 
     if (mgmtEnabled) {
       const { ManagementClient } = await import('./management.js')
-      const ops = typeof applicationConfig.management === 'object'
-        ? applicationConfig.management.operations
-        : undefined
+      const ops = typeof applicationConfig.management === 'object' ? applicationConfig.management.operations : undefined
       updateGlobals({ management: new ManagementClient(ops) })
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.57.0",
+  "version": "3.58.1",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -18,6 +18,7 @@
     "@fastify/compress": "^8.0.0",
     "@fastify/express": "^4.0.0",
     "@fastify/formbody": "^8.0.0",
+    "@sentry/node": "^10.58.0",
     "atomic-sleep": "^1.0.0",
     "autocannon": "^8.0.0",
     "c8": "^11.0.0",
@@ -31,19 +32,20 @@
     "json-schema-to-typescript": "^15.0.0",
     "neostandard": "^0.12.0",
     "pino-abstract-transport": "^2.0.0",
+    "pino-sentry-transport": "^1.6.0",
     "split2": "^4.2.0",
     "tstyche": "^6.2.0",
     "typescript": "^5.5.4",
-    "undici-oidc-interceptor": "^0.5.0",
+    "undici-oidc-interceptor": "^0.9.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/db": "3.57.0",
-    "@platformatic/node": "3.57.0",
-    "@platformatic/composer": "3.57.0",
-    "@platformatic/gateway": "3.57.0",
-    "@platformatic/service": "3.57.0",
-    "@platformatic/sql-graphql": "3.57.0",
-    "@platformatic/wattpm-pprof-capture": "3.57.0",
-    "@platformatic/sql-mapper": "3.57.0"
+    "@platformatic/composer": "3.58.1",
+    "@platformatic/gateway": "3.58.1",
+    "@platformatic/node": "3.58.1",
+    "@platformatic/sql-graphql": "3.58.1",
+    "@platformatic/sql-mapper": "3.58.1",
+    "@platformatic/db": "3.58.1",
+    "@platformatic/service": "3.58.1",
+    "@platformatic/wattpm-pprof-capture": "3.58.1"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -52,7 +54,7 @@
     "@fastify/websocket": "^11.0.0",
     "@opentelemetry/api": "^1.9.0",
     "@platformatic/prom-client": "^1.0.0",
-    "@platformatic/undici-cache-memory": "^0.8.1",
+    "@platformatic/undici-cache-memory": "^0.9.0",
     "@watchable/unpromise": "^1.0.2",
     "change-case-all": "^2.1.0",
     "close-with-grace": "^2.3.0",
@@ -73,13 +75,13 @@
     "undici": "^7.27.2",
     "undici-thread-interceptor": "^1.3.1",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.57.0",
-    "@platformatic/globals": "3.57.0",
-    "@platformatic/generators": "3.57.0",
-    "@platformatic/foundation": "3.57.0",
-    "@platformatic/itc": "3.57.0",
-    "@platformatic/metrics": "3.57.0",
-    "@platformatic/telemetry": "3.57.0"
+    "@platformatic/basic": "3.58.1",
+    "@platformatic/foundation": "3.58.1",
+    "@platformatic/globals": "3.58.1",
+    "@platformatic/generators": "3.58.1",
+    "@platformatic/metrics": "3.58.1",
+    "@platformatic/itc": "3.58.1",
+    "@platformatic/telemetry": "3.58.1"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.57.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.58.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -1928,7 +1928,14 @@
     },
     "exitOnUnhandledErrors": {
       "default": true,
-      "type": "boolean"
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "number"
+        }
+      ]
     },
     "gracefulShutdown": {
       "type": "object",
@@ -2110,6 +2117,17 @@
       },
       "additionalProperties": false
     },
+    "healthProbes": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string"
+        }
+      ],
+      "default": true
+    },
     "undici": {
       "type": "object",
       "properties": {