@platformatic/runtime 3.71.1-alpha.0 → 4.0.0-alpha.1

package/lib/worker/main.js

@@ -7,19 +7,18 @@ import {
   parseMemorySize,
   scheduleCompileCacheFlush
 } from '@platformatic/foundation'
-import { getITC, getLogger, updateGlobals } from '@platformatic/globals'
-import { addPinoInstrumentation } from '@platformatic/telemetry'
+import { getITC, getLogger, setUndiciThreadInterceptor, updateGlobals } from '@platformatic/globals'
+import { addPinoInstrumentation } from '@platformatic/tracing'
 import { Buffer } from 'node:buffer'
 import { subscribe } from 'node:diagnostics_channel'
 import { EventEmitter } from 'node:events'
-import { readFile } from 'node:fs/promises'
 import { ServerResponse } from 'node:http'
 import inspector from 'node:inspector'
+import { constants as moduleConstants, enableCompileCache } from 'node:module'
 import { hostname } from 'node:os'
-import { join, resolve } from 'node:path'
+import { join } from 'node:path'
 import { setDefaultHighWaterMark } from 'node:stream'
 import { pathToFileURL } from 'node:url'
-import { parseEnv } from 'node:util'
 import { threadId, workerData } from 'node:worker_threads'
 import pino from 'pino'
 import { install as installUndiciGlobals } from 'undici'
@@ -101,7 +100,7 @@ function createLogger () {
     pinoOptions.timestamp = buildPinoTimestamp(pinoOptions.timestamp)
   }
 
-  if (workerData.config.logger?.openTelemetryExporter && workerData.applicationConfig.telemetry?.enabled !== false) {
+  if (workerData.config.logger?.openTelemetryExporter && workerData.applicationConfig.tracing?.enabled !== false) {
     addPinoInstrumentation(pinoOptions)
   }
 
@@ -150,10 +149,9 @@ function setupDefaultHighWaterMark (runtimeConfig, applicationConfig, logger) {
   }
 }
 
-// Whether the module compile cache has been enabled in this worker.
 let compileCacheEnabled = false
+let compileCacheRequested = false
 
-// Enable compile cache if configured (Node.js 22.1.0+)
 async function setupCompileCache (runtimeConfig, applicationConfig, logger) {
   // Normalize boolean shorthand: true -> { enabled: true }
   const normalizeConfig = cfg => {
@@ -171,34 +169,23 @@ async function setupCompileCache (runtimeConfig, applicationConfig, logger) {
     return
   }
 
-  // Check if API is available (Node.js 22.1.0+)
-  let moduleApi
-  try {
-    moduleApi = await import('node:module')
-    if (typeof moduleApi.enableCompileCache !== 'function') {
-      return
-    }
-  } catch {
-    return
-  }
-
+  compileCacheRequested = true
   // Determine cache directory - use applicationConfig.path for the app root
   const cacheDir = config.directory ?? join(applicationConfig.path, '.plt', 'compile-cache')
 
   try {
-    const result = moduleApi.enableCompileCache(cacheDir)
-
-    const { compileCacheStatus } = moduleApi.constants ?? {}
+    const result = enableCompileCache(cacheDir)
+    const { compileCacheStatus } = moduleConstants
 
-    if (result.status === compileCacheStatus?.ENABLED) {
+    if (result.status === compileCacheStatus.ENABLED) {
       compileCacheEnabled = true
       logger.debug({ directory: result.directory }, 'Module compile cache enabled')
-    } else if (result.status === compileCacheStatus?.ALREADY_ENABLED) {
+    } else if (result.status === compileCacheStatus.ALREADY_ENABLED) {
       compileCacheEnabled = true
       logger.debug({ directory: result.directory }, 'Module compile cache already enabled')
-    } else if (result.status === compileCacheStatus?.FAILED) {
+    } else if (result.status === compileCacheStatus.FAILED) {
       logger.warn({ message: result.message }, 'Failed to enable module compile cache')
-    } else if (result.status === compileCacheStatus?.DISABLED) {
+    } else if (result.status === compileCacheStatus.DISABLED) {
       logger.debug('Module compile cache disabled via NODE_DISABLE_COMPILE_CACHE')
     }
   } catch (err) {
@@ -237,56 +224,20 @@ async function main () {
 
   await performPreloading(runtimeConfig, applicationConfig)
 
-  // Load env file and mixin env vars from application config
-  let envfile
-  if (applicationConfig.envfile) {
-    envfile = resolve(workerData.dirname, applicationConfig.envfile)
-  } else {
-    envfile = resolve(workerData.applicationConfig.path, '.env')
-  }
-
-  const logger = getLogger()
-  logger.debug({ envfile }, 'Loading envfile...')
-
-  // Note that process.loadEnvFile is not used here as it never overrides an already defined
-  // variable. The worker environment is seeded from the environment the runtime resolved, which
-  // might contain values coming from an env file of the runtime. Those are only defaults, so the
-  // env file of this application, which is more specific, is allowed to override them. Real
-  // environment variables are never overridden.
-  const envFileFallbackKeys = new Set(workerData.envFileFallbackKeys ?? [])
-
-  try {
-    const applicationEnv = parseEnv(await readFile(envfile, 'utf-8'))
-
-    for (const [key, value] of Object.entries(applicationEnv)) {
-      if (!(key in process.env) || envFileFallbackKeys.has(key)) {
-        process.env[key] = value
-      }
-    }
-  } catch {
-    // Ignore if the file doesn't exist, similar to dotenv behavior
-  }
-
-  if (runtimeConfig.env) {
-    Object.assign(process.env, runtimeConfig.env)
-  }
-  if (applicationConfig.env) {
-    Object.assign(process.env, applicationConfig.env)
-  }
+  /*
+    Nothing is layered onto process.env here, and that absence is load-bearing. The loader resolved
+    this worker's entire environment main-side -- env-file chains, both env blocks, the injected
+    topology URLs, with the real environment authoritative over all of them -- and the worker was
+    *spawned* with that result. Re-reading a .env or re-applying an env block on top re-decides
+    what was already decided, with the opposite precedence: env blocks were once treated as pins over
+    the real environment, and that inversion is now a breaking change -- the real environment is
+    authoritative. The suppression of a block value by the real environment is reported at boot,
+    main-side, where the ladder is resolved.
+  */
+  getLogger().debug('Using the worker environment resolved by the loader.')
 
   const { threadDispatcher } = await setDispatcher(runtimeConfig)
-
-  // If the application is an entrypoint and runtime server config is defined, use it.
-  let serverConfig = null
-  if (runtimeConfig.server && applicationConfig.entrypoint) {
-    serverConfig = runtimeConfig.server
-  } else if (applicationConfig.useHttp || applicationConfig.websocket) {
-    serverConfig = {
-      port: 0,
-      hostname: '127.0.0.1',
-      keepAliveTimeout: 5000
-    }
-  }
+  setUndiciThreadInterceptor(threadDispatcher.interceptor)
 
   const inspectorOptions = workerData.inspectorOptions
 
@@ -319,40 +270,41 @@ async function main () {
     runtimeConfig,
     applicationConfig,
     workerData.worker.index,
-    serverConfig,
     metricsConfig
   )
 
+  const sharedContext = new SharedContext()
+  updateGlobals({
+    sharedContext: {
+      get: () => sharedContext.get(),
+      update: (...args) => sharedContext.update(...args)
+    }
+  })
+
+  // Setup interaction with the parent before loading the application so plugins
+  // can register messaging handlers during their initialization.
+  const itc = await setupITC(controller, applicationConfig, threadDispatcher, sharedContext)
+  updateGlobals({ itc })
+
   await controller.init(cleanup)
 
-  // Make the compile cache accumulated while booting durable, as Node.js would otherwise only write
-  // it when the worker terminates.
   controller.on('started', () => {
     if (compileCacheEnabled) {
-      scheduleCompileCacheFlush(logger)
+      scheduleCompileCacheFlush(getLogger(), flushed => {
+        getITC().notify('compile-cache:flushed', { flushed, source: 'worker' })
+      })
+    } else if (compileCacheRequested) {
+      getITC().notify('compile-cache:unavailable', { source: 'worker' })
     }
   })
 
-  if (applicationConfig.entrypoint && runtimeConfig.basePath) {
+  if (runtimeConfig.basePath) {
     const meta = await controller.capability.getMeta()
-    if (!meta.gateway.wantsAbsoluteUrls) {
+    if (!meta.gateway?.wantsAbsoluteUrls) {
       stripBasePath(runtimeConfig.basePath)
     }
   }
 
-  const sharedContext = new SharedContext()
-  // Limit the amount of methods a user can call
-  updateGlobals({
-    sharedContext: {
-      get: () => sharedContext.get(),
-      update: (...args) => sharedContext.update(...args)
-    }
-  })
-
-  // Setup interaction with parent port
-  const itc = await setupITC(controller, applicationConfig, threadDispatcher, sharedContext)
-  updateGlobals({ itc })
-
   // Setup management client for privileged applications
   if (applicationConfig.management) {
     const mgmtEnabled =
@@ -412,7 +364,9 @@ function stripBasePath (basePath) {
         request.url = '/' + request.url
       }
 
-      response[kBasePath] = basePath
+      if (response) {
+        response[kBasePath] = basePath
+      }
     }
   })
 
@@ -439,10 +393,8 @@ function stripBasePath (basePath) {
   }
 
   ServerResponse.prototype.setHeader = function (name, value) {
-    if (this[kBasePath]) {
-      if (name.toLowerCase() === 'location') {
-        value = prependBasePath(value)
-      }
+    if (this[kBasePath] && name.toLowerCase() === 'location') {
+      value = prependBasePath(value)
     }
     originSetHeader.call(this, name, value)
   }

package/lib/worker/messaging.js

@@ -27,6 +27,8 @@ export class MessagingITC extends ITC {
   #workers
   #sources
   #logger
+  #referenced = true
+  #activeHandlers = 0
 
   constructor (id, runtimeConfig, logger) {
     super({
@@ -58,6 +60,34 @@ export class MessagingITC extends ITC {
     this.#listener = listener
   }
 
+  unref () {
+    this.#referenced = false
+    this.#updateRefs()
+    return this
+  }
+
+  ref () {
+    this.#referenced = true
+    this.#updateRefs()
+    return this
+  }
+
+  #updateRefs () {
+    // Outgoing ITC requests own their keep-alive timer; incoming handlers need a
+    // reference until their response is ready, even if their work is remote I/O.
+    this.#broadcastChannel[this.#referenced || this.#activeHandlers > 0 ? 'ref' : 'unref']()
+    const method = this.#referenced ? 'ref' : 'unref'
+    for (const channel of this.#notificationsChannels.values()) {
+      channel[method]()
+    }
+    for (const channel of this.#sources) {
+      channel[method]()
+    }
+    for (const worker of this.#workers.values()) {
+      worker.channel?.[method]()
+    }
+  }
+
   handle (message, handler) {
     if (typeof message === 'object') {
       for (const [name, fn] of Object.entries(message)) {
@@ -152,6 +182,7 @@ export class MessagingITC extends ITC {
       if (!channel) {
         channel = new BroadcastChannel(`plt.messaging.notifications-${application}`)
         this.#notificationsChannels.set(application, channel)
+        this.#updateRefs()
       }
 
       const postMessage = () => channel.postMessage(sanitize(request))
@@ -235,6 +266,7 @@ export class MessagingITC extends ITC {
       this.#sources.delete(channel)
       this.#handlePendingResponse(channel)
     })
+    this.#updateRefs()
   }
 
   #updateWorkers (event) {
@@ -282,7 +314,16 @@ export class MessagingITC extends ITC {
   }
 
   #wrapHandler (messageName, handler) {
-    return (data, context) => traceIncomingMessagingHandler(this.#id, messageName, handler, data, context)
+    return async (data, context) => {
+      this.#activeHandlers++
+      this.#updateRefs()
+      try {
+        return await traceIncomingMessagingHandler(this.#id, messageName, handler, data, context)
+      } finally {
+        this.#activeHandlers--
+        this.#updateRefs()
+      }
+    }
   }
 
   #handlePendingResponse (channel) {

package/lib/worker/round-robin-map.js

@@ -46,15 +46,22 @@ export class RoundRobinMap extends Map {
     return [...(this.#instances[application]?.keys ?? [])]
   }
 
-  next (application) {
+  next (application, filter) {
     if (!this.#instances[application]) return
 
     let { next, keys } = this.#instances[application]
     if (next === null) {
       next = Math.floor(Math.random() * keys.length)
     }
-    this.#instances[application].next = (next + 1) % keys.length
 
-    return this.get(keys[next])
+    for (let i = 0; i < keys.length; i++) {
+      const candidate = (next + i) % keys.length
+      const worker = this.get(keys[candidate])
+
+      if (!filter || filter(worker)) {
+        this.#instances[application].next = (candidate + 1) % keys.length
+        return worker
+      }
+    }
   }
 }

package/lib/worker/symbols.js

@@ -6,12 +6,16 @@ export const kWorkerId = Symbol.for('plt.runtime.worker.id')
 export const kITC = Symbol.for('plt.runtime.itc')
 export const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer')
 export const kWorkerStatus = Symbol('plt.runtime.worker.status')
+export const kWorkerExitCode = Symbol('plt.runtime.worker.exitCode')
 export const kWorkerHealthSignals = Symbol.for('plt.runtime.worker.healthSignals')
+export const kWorkerStartAborted = Symbol('plt.runtime.worker.startAborted')
 export const kWorkerStartTime = Symbol.for('plt.runtime.worker.startTime')
+export const kWorkerUrl = Symbol.for('plt.runtime.worker.url')
+export const kWorkerPortOffset = Symbol.for('plt.runtime.worker.portOffset')
+export const kWorkerServerOptions = Symbol.for('plt.runtime.worker.serverOptions')
 export const kLastHealthCheckELU = Symbol.for('plt.runtime.worker.lastHealthCheckELU')
-export const kLastWorkerScalerELU = Symbol.for('plt.runtime.worker.lastWorkerScalerELU')
-export const kInterceptorReadyPromise = Symbol.for('plt.runtime.worker.interceptorReadyPromise')
 export const kIsSubprocessHost = Symbol.for('plt.runtime.worker.isSubprocessHost')
+export const kSubprocessPid = Symbol('subprocessPid')
 
 // This string marker should be safe to use since it belongs to Unicode private area
 export const kStderrMarker = '\ue002'

package/package.json

@@ -1,9 +1,18 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.71.1-alpha.0",
+  "version": "4.0.0-alpha.1",
   "description": "Platformatic runtime",
   "main": "index.js",
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./schema": "./lib/schema.js",
+    "./package.json": "./package.json",
+    "./*": "./*"
+  },
   "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "repository": {
     "type": "git",
@@ -39,14 +48,13 @@
     "typescript": "~6.0.3",
     "undici-oidc-interceptor": "^0.9.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "3.71.1-alpha.0",
-    "@platformatic/db": "3.71.1-alpha.0",
-    "@platformatic/gateway": "3.71.1-alpha.0",
-    "@platformatic/service": "3.71.1-alpha.0",
-    "@platformatic/node": "3.71.1-alpha.0",
-    "@platformatic/sql-graphql": "3.71.1-alpha.0",
-    "@platformatic/wattpm-pprof-capture": "3.71.1-alpha.0",
-    "@platformatic/sql-mapper": "3.71.1-alpha.0"
+    "@platformatic/db": "4.0.0-alpha.1",
+    "@platformatic/gateway": "4.0.0-alpha.1",
+    "@platformatic/node": "4.0.0-alpha.1",
+    "@platformatic/service": "4.0.0-alpha.1",
+    "@platformatic/sql-graphql": "4.0.0-alpha.1",
+    "@platformatic/wattpm-pprof-capture": "4.0.0-alpha.1",
+    "@platformatic/sql-mapper": "4.0.0-alpha.1"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -72,25 +80,26 @@
     "pino-opentelemetry-transport": "^4.0.2",
     "pino-pretty": "^13.0.0",
     "semgrator": "^0.3.0",
+    "semver": "^7.6.3",
     "sonic-boom": "^4.2.0",
     "systeminformation": "^5.27.11",
-    "undici": "^7.27.2",
-    "undici-thread-interceptor": "^1.3.1",
+    "undici": "^8.5.0",
+    "undici-thread-interceptor": "^2.2.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.71.1-alpha.0",
-    "@platformatic/foundation": "3.71.1-alpha.0",
-    "@platformatic/generators": "3.71.1-alpha.0",
-    "@platformatic/globals": "3.71.1-alpha.0",
-    "@platformatic/itc": "3.71.1-alpha.0",
-    "@platformatic/metrics": "3.71.1-alpha.0",
-    "@platformatic/telemetry": "3.71.1-alpha.0"
+    "@platformatic/basic": "4.0.0-alpha.1",
+    "@platformatic/foundation": "4.0.0-alpha.1",
+    "@platformatic/generators": "4.0.0-alpha.1",
+    "@platformatic/itc": "4.0.0-alpha.1",
+    "@platformatic/metrics": "4.0.0-alpha.1",
+    "@platformatic/globals": "4.0.0-alpha.1",
+    "@platformatic/tracing": "4.0.0-alpha.1"
   },
   "engines": {
-    "node": ">=22.19.0"
+    "node": ">=24.20.0"
   },
   "scripts": {
     "test": "npm run test:types && npm run test:main && npm run test:api && npm run test:cli && npm run test:start && npm run test:multiple-workers",
-    "test:main": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/versions/*.test.js",
+    "test:main": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/versions/*.test.js test/predictive-scaling/*.test.js",
     "test:api": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/api/*.test.js test/management-api/*.test.js",
     "test:cli": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/cli/*.test.js test/cli/**/*.test.js",
     "test:start": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/start/*.test.js",