@platformatic/runtime 3.36.0 → 3.38.0

package/config.d.ts

@@ -517,6 +517,7 @@ export type PlatformaticRuntimeConfig = {
     [k: string]: unknown;
   };
   applicationTimeout?: number | string;
+  startupConcurrency?: number | string;
   messagingTimeout?: number | string;
   resolvedApplicationsBasePath?: string;
   env?: {

package/index.js

@@ -146,7 +146,12 @@ export async function create (configOrRoot, sourceOrConfig, context) {
   if (context?.start) {
     let port = config.server?.port
 
-    await runtime.init()
+    try {
+      await runtime.init()
+    } catch (err) {
+      await runtime.close()
+      throw err
+    }
 
     if (context.reloaded) {
       runtime.logger.info('The application has been successfully reloaded.')

package/lib/config.js

@@ -230,37 +230,44 @@ export async function prepareApplication (config, application, defaultWorkers) {
     application.config = resolvePath(application.path, application.config)
   }
 
-  try {
-    let pkg
+  // Skip capability detection for external services (url without path)
+  // These services will have their path resolved later in runtime.js #setupApplication
+  // Attempting to detect capability here would cause slow glob operations on the cwd
+  if (application.url && !application.path) {
+    application.type = 'unknown'
+  } else {
+    try {
+      let pkg
 
-    if (application.config) {
-      const config = await loadConfiguration(application.config)
-      pkg = await loadConfigurationModule(application.path, config)
+      if (application.config) {
+        const config = await loadConfiguration(application.config)
+        pkg = await loadConfigurationModule(application.path, config)
 
-      application.type = extractModuleFromSchemaUrl(config, true).module
-      application.skipTelemetryHooks = pkg.skipTelemetryHooks
-    } else {
-      const { moduleName, capability } = await importCapabilityAndConfig(application.path)
-      pkg = capability
+        application.type = extractModuleFromSchemaUrl(config, true).module
+        application.skipTelemetryHooks = pkg.skipTelemetryHooks
+      } else {
+        const { moduleName, capability } = await importCapabilityAndConfig(application.path)
+        pkg = capability
 
-      application.type = moduleName
-    }
+        application.type = moduleName
+      }
 
-    application.skipTelemetryHooks = pkg.skipTelemetryHooks
+      application.skipTelemetryHooks = pkg.skipTelemetryHooks
 
-    // This is needed to work around Rust bug on dylibs:
-    // https://github.com/rust-lang/rust/issues/91979
-    // https://github.com/rollup/rollup/issues/5761
-    const _require = createRequire(application.path)
-    for (const m of pkg.modulesToLoad ?? []) {
-      const toLoad = _require.resolve(m)
-      loadModule(_require, toLoad).catch(() => {})
+      // This is needed to work around Rust bug on dylibs:
+      // https://github.com/rust-lang/rust/issues/91979
+      // https://github.com/rollup/rollup/issues/5761
+      const _require = createRequire(application.path)
+      for (const m of pkg.modulesToLoad ?? []) {
+        const toLoad = _require.resolve(m)
+        loadModule(_require, toLoad).catch(() => {})
+      }
+    } catch (err) {
+      // This should not happen, it happens on running some unit tests if we prepare the runtime
+      // when not all the applications configs are available. Given that we are running this only
+      // to ddetermine the type of the application, it's safe to ignore this error and default to unknown
+      application.type = 'unknown'
     }
-  } catch (err) {
-    // This should not happen, it happens on running some unit tests if we prepare the runtime
-    // when not all the applications configs are available. Given that we are running this only
-    // to ddetermine the type of the application, it's safe to ignore this error and default to unknown
-    application.type = 'unknown'
   }
 
   // Validate and coerce per-service workers

package/lib/errors.js

@@ -1,5 +1,14 @@
 import createError from '@fastify/error'
 
+// Keep in sync with packages/basic/lib/errors.js
+export const exitCodes = {
+  MANAGER_MESSAGE_HANDLING_FAILED: 11,
+  MANAGER_SOCKET_ERROR: 11,
+  PROCESS_UNHANDLED_ERROR: 20,
+  PROCESS_MESSAGE_HANDLING_FAILED: 21,
+  PROCESS_SOCKET_ERROR: 22
+}
+
 export const ERROR_PREFIX = 'PLT_RUNTIME'
 
 export const AddressInUseError = createError(

package/lib/generator.js

@@ -113,6 +113,10 @@ export class RuntimeGenerator extends BaseGenerator {
       template.workspaces = [this.applicationsFolder + '/*']
     }
 
+    if (this.packageManager === 'yarn') {
+      template.private = true
+    }
+
     return template
   }
 

package/lib/runtime.js

@@ -92,7 +92,7 @@ function parseOrigins (origins) {
 }
 
 // Always run operations in parallel to avoid deadlocks when services have dependencies
-const MAX_CONCURRENCY = availableParallelism()
+const DEFAULT_CONCURRENCY = availableParallelism() * 2
 const MAX_BOOTSTRAP_ATTEMPTS = 5
 const IMMEDIATE_RESTART_MAX_THRESHOLD = 10
 const MAX_WORKERS = 100
@@ -151,7 +151,7 @@ export class Runtime extends EventEmitter {
     this.#env = config[kMetadata].env
     this.#context = context ?? {}
     this.#isProduction = this.#context.isProduction ?? this.#context.production ?? false
-    this.#concurrency = this.#context.concurrency ?? MAX_CONCURRENCY
+    this.#concurrency = Math.max(1, config.startupConcurrency ?? this.#context.concurrency ?? DEFAULT_CONCURRENCY)
     this.#applications = new Map()
     this.#workers = new RoundRobinMap()
     this.#url = undefined
@@ -1608,7 +1608,7 @@ export class Runtime extends EventEmitter {
     this.emitAndNotify('application:init', id)
   }
 
-  async #setupWorker (config, applicationConfig, workersCount, applicationId, index, enabled = true) {
+  async #setupWorker (config, applicationConfig, workersCount, applicationId, index, enabled = true, attempt = 0) {
     const { restartOnError } = config
     const workerId = `${applicationId}:${index}`
 
@@ -1854,12 +1854,21 @@ export class Runtime extends EventEmitter {
     try {
       await waitEventFromITC(worker, 'init')
     } catch (e) {
+      if (attempt === MAX_BOOTSTRAP_ATTEMPTS) {
+        const error = new RuntimeAbortedError({ cause: e })
+        error.message = `Unable to initialize the ${errorLabel}.`
+        throw e
+      }
+
       if (e.code !== 'PLT_RUNTIME_APPLICATION_WORKER_EXIT') {
-        this.logger.error({ err: ensureLoggableError(e) }, `Failed to initialize the ${errorLabel}. Replacing it ...`)
+        this.logger.error(
+          { err: ensureLoggableError(e) },
+          `Failed to initialize the ${errorLabel}. Attempting to initialize a new worker ...`
+        )
       }
 
       this.#workers.delete(workerId)
-      return this.#setupWorker(config, applicationConfig, workersCount, applicationId, index, enabled)
+      return this.#setupWorker(config, applicationConfig, workersCount, applicationId, index, enabled, attempt + 1)
     }
 
     if (applicationConfig.entrypoint) {

package/lib/worker/controller.js

@@ -100,7 +100,7 @@ export class Controller extends EventEmitter {
   }
 
   // Note: capability's init() is executed within start
-  async init () {
+  async init (cleanupHandlers) {
     try {
       const appConfig = this.applicationConfig
 
@@ -133,6 +133,10 @@ export class Controller extends EventEmitter {
 
       this.#updateDispatcher()
 
+      if (cleanupHandlers) {
+        cleanupHandlers()
+      }
+
       if (this.capability.exitOnUnhandledErrors && this.runtimeConfig.exitOnUnhandledErrors) {
         this.#setupHandlers()
       }

package/lib/worker/itc.js

@@ -14,7 +14,8 @@ import {
   FailedToRetrieveMetaError,
   FailedToRetrieveMetricsError,
   FailedToRetrieveOpenAPISchemaError,
-  WorkerExitedError
+  WorkerExitedError,
+  exitCodes
 } from '../errors.js'
 import { updateUndiciInterceptors } from './interceptors.js'
 import { MessagingITC } from './messaging.js'
@@ -86,7 +87,7 @@ async function safeHandleInITC (worker, fn) {
     ])
 
     if (typeof exitCode === 'number') {
-      if (typeof worker[kWorkerId] !== 'undefined') {
+      if (typeof worker[kWorkerId] !== 'undefined' && exitCode !== exitCodes.PROCESS_UNHANDLED_ERROR) {
         throw new WorkerExitedError(worker[kWorkerId], worker[kApplicationId], exitCode)
       } else {
         throw new ApplicationExitedError(worker[kId], exitCode)

package/lib/worker/main.js

@@ -2,6 +2,7 @@ import {
   buildPinoFormatters,
   buildPinoTimestamp,
   disablePinoDirectWrite,
+  ensureLoggableError,
   getPrivateSymbol
 } from '@platformatic/foundation'
 import { subscribe } from 'node:diagnostics_channel'
@@ -14,12 +15,22 @@ import { pathToFileURL } from 'node:url'
 import { threadId, workerData } from 'node:worker_threads'
 import pino from 'pino'
 import { install as installUndiciGlobals } from 'undici'
+import { exitCodes } from '../errors.js'
 import { Controller } from './controller.js'
+import { initHealthSignalsApi } from './health-signals.js'
 import { setDispatcher } from './interceptors.js'
 import { setupITC } from './itc.js'
 import { SharedContext } from './shared-context.js'
 import { kId, kITC, kStderrMarker } from './symbols.js'
-import { initHealthSignalsApi } from './health-signals.js'
+
+function handlePreInitializationUnhandled (type, err) {
+  const label = `worker ${workerData.worker.index} of the application "${workerData.applicationConfig.id}"`
+  globalThis.platformatic.logger.error(
+    { err: ensureLoggableError(err) },
+    `The ${label} threw an ${type} before initialization.`
+  )
+  process.exit(exitCodes.PROCESS_UNHANDLED_ERROR)
+}
 
 class ForwardingEventEmitter extends EventEmitter {
   emitAndNotify (event, ...args) {
@@ -50,6 +61,18 @@ function patchLogging () {
   }
 }
 
+function setupHandlers () {
+  const unhandledExceptionHandler = handlePreInitializationUnhandled.bind(null, 'uncaught exception')
+  const unhandledRejectionHandler = handlePreInitializationUnhandled.bind(null, 'uncaught rejection')
+  process.on('uncaughtException', unhandledExceptionHandler)
+  process.on('unhandledRejection', unhandledRejectionHandler)
+
+  return () => {
+    process.removeListener('uncaughtException', unhandledExceptionHandler)
+    process.removeListener('unhandledRejection', unhandledRejectionHandler)
+  }
+}
+
 function createLogger () {
   // Do not propagate runtime transports to the worker
   if (workerData.config.logger) {
@@ -137,6 +160,8 @@ async function setupCompileCache (runtimeConfig, applicationConfig, logger) {
 }
 
 async function main () {
+  const cleanup = setupHandlers()
+
   installUndiciGlobals(globalThis)
   globalThis[kId] = threadId
   globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, {
@@ -224,7 +249,7 @@ async function main () {
     metricsConfig
   )
 
-  await controller.init()
+  await controller.init(cleanup)
 
   if (applicationConfig.entrypoint && runtimeConfig.basePath) {
     const meta = await controller.capability.getMeta()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.36.0",
+  "version": "3.38.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -35,14 +35,14 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "3.36.0",
-    "@platformatic/db": "3.36.0",
-    "@platformatic/node": "3.36.0",
-    "@platformatic/service": "3.36.0",
-    "@platformatic/sql-graphql": "3.36.0",
-    "@platformatic/sql-mapper": "3.36.0",
-    "@platformatic/wattpm-pprof-capture": "3.36.0",
-    "@platformatic/gateway": "3.36.0"
+    "@platformatic/db": "3.38.0",
+    "@platformatic/composer": "3.38.0",
+    "@platformatic/gateway": "3.38.0",
+    "@platformatic/node": "3.38.0",
+    "@platformatic/service": "3.38.0",
+    "@platformatic/sql-graphql": "3.38.0",
+    "@platformatic/sql-mapper": "3.38.0",
+    "@platformatic/wattpm-pprof-capture": "3.38.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -69,14 +69,14 @@
     "sonic-boom": "^4.2.0",
     "systeminformation": "^5.27.11",
     "undici": "^7.0.0",
-    "undici-thread-interceptor": "^1.3.0",
+    "undici-thread-interceptor": "^1.3.1",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.36.0",
-    "@platformatic/foundation": "3.36.0",
-    "@platformatic/itc": "3.36.0",
-    "@platformatic/generators": "3.36.0",
-    "@platformatic/metrics": "3.36.0",
-    "@platformatic/telemetry": "3.36.0"
+    "@platformatic/foundation": "3.38.0",
+    "@platformatic/basic": "3.38.0",
+    "@platformatic/generators": "3.38.0",
+    "@platformatic/itc": "3.38.0",
+    "@platformatic/telemetry": "3.38.0",
+    "@platformatic/metrics": "3.38.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.36.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.38.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -2583,6 +2583,17 @@
       ],
       "default": 300000
     },
+    "startupConcurrency": {
+      "anyOf": [
+        {
+          "type": "number",
+          "minimum": 1
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
     "messagingTimeout": {
       "anyOf": [
         {