@platformatic/runtime 2.67.0-alpha.1 → 2.67.0

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export type HttpsSchemasPlatformaticDevPlatformaticRuntime2670Alpha1Json = {
+export type HttpsSchemasPlatformaticDevPlatformaticRuntime2670Json = {
   [k: string]: unknown;
 } & {
   $schema?: string;

package/lib/config.js

@@ -251,7 +251,7 @@ platformaticRuntime.configManagerConfig = {
   upgrade
 }
 
-async function wrapConfigInRuntimeConfig ({ configManager, args }) {
+async function wrapConfigInRuntimeConfig ({ configManager, args, opts }) {
   let serviceId = 'main'
   try {
     const packageJson = join(configManager.dirname, 'package.json')
@@ -272,7 +272,7 @@ async function wrapConfigInRuntimeConfig ({ configManager, args }) {
   const wrapperConfig = {
     $schema: schema.$id,
     server,
-    watch: true,
+    watch: !args?.production,
     ...omitProperties(configManager.current.runtime ?? {}, runtimeUnwrappablePropertiesList),
     entrypoint: serviceId,
     services: [
@@ -298,7 +298,7 @@ async function wrapConfigInRuntimeConfig ({ configManager, args }) {
     }
   })
 
-  await cm.parseAndValidate()
+  await cm.parseAndValidate(true, [], opts)
 
   return cm
 }

package/lib/errors.js

@@ -38,6 +38,7 @@ module.exports = {
   FailedToUnlinkManagementApiSocket: createError(`${ERROR_PREFIX}_FAILED_TO_UNLINK_MANAGEMENT_API_SOCKET`, 'Failed to unlink management API socket "%s"'),
   LogFileNotFound: createError(`${ERROR_PREFIX}_LOG_FILE_NOT_FOUND`, 'Log file with index %s not found', 404),
   WorkerIsRequired: createError(`${ERROR_PREFIX}_REQUIRED_WORKER`, 'The worker parameter is required'),
+  InvalidArgumentError: createError(`${ERROR_PREFIX}_INVALID_ARGUMENT`, 'Invalid argument: "%s"'),
 
   // TODO: should remove next one as it's not used anymore
   CannotRemoveServiceOnUpdateError: createError(`${ERROR_PREFIX}_CANNOT_REMOVE_SERVICE_ON_UPDATE`, 'Cannot remove service "%s" when updating a Runtime'),

package/lib/generator/runtime-generator.js

@@ -150,6 +150,9 @@ class RuntimeGenerator extends BaseGenerator {
       this.config.port = configManager.env.PORT
       this.entryPoint = configManager.current.services.find(svc => svc.entrypoint)
       this.existingServices = configManager.current.services.map(s => s.id)
+
+      this.updateRuntimeConfig(this.existingConfigRaw)
+      this.updateRuntimeEnv(await readFile(join(this.targetDirectory, '.env'), 'utf-8'))
     }
   }
 
@@ -204,11 +207,7 @@ class RuntimeGenerator extends BaseGenerator {
       ...servicesEnv
     })
 
-    this.addFile({
-      path: '',
-      file: '.env',
-      contents: envObjectToString(this.config.env)
-    })
+    this.updateRuntimeEnv(envObjectToString(this.config.env))
 
     this.addFile({
       path: '',
@@ -227,12 +226,21 @@ class RuntimeGenerator extends BaseGenerator {
   }
 
   async writeFiles () {
+    for (const { service } of this.services) {
+      await service._beforeWriteFiles?.(this)
+    }
+
     await super.writeFiles()
+
     if (!this.config.isUpdating) {
       for (const { service } of this.services) {
         await service.writeFiles()
       }
     }
+
+    for (const { service } of this.services) {
+      await service._afterWriteFiles?.(this)
+    }
   }
 
   async prepareQuestions () {
@@ -275,6 +283,7 @@ class RuntimeGenerator extends BaseGenerator {
       } else {
         basePath = join(this.targetDirectory, this.config.autoload || this.servicesFolder)
       }
+      this.servicesBasePath = basePath
       service.setTargetDirectory(join(basePath, service.config.serviceName))
     })
   }
@@ -496,16 +505,59 @@ class RuntimeGenerator extends BaseGenerator {
 
       this.setEntryPoint(newEntrypoint)
       runtimePkgConfigFileData.entrypoint = newEntrypoint
-      this.addFile({
-        path: '',
-        file: this.runtimeConfig,
-        contents: JSON.stringify(runtimePkgConfigFileData, null, 2)
-      })
+      this.updateRuntimeConfig(runtimePkgConfigFileData)
     }
     await this.writeFiles()
     // save new env
     await envTool.save()
   }
+
+  async generateConfigFile () {
+    this.updateRuntimeConfig(await super.generateConfigFile())
+  }
+
+  async generateEnv () {
+    const serialized = await super.generateEnv()
+
+    if (serialized) {
+      this.updateRuntimeEnv(serialized)
+    }
+  }
+
+  getRuntimeConfigFileObject () {
+    return this.files.find(file => file.tags?.includes('runtime-config')) ?? null
+  }
+
+  getRuntimeEnvFileObject () {
+    return this.files.find(file => file.tags?.includes('runtime-env')) ?? null
+  }
+
+  updateRuntimeConfig (config) {
+    this.addFile({
+      path: '',
+      file: this.runtimeConfig,
+      contents: JSON.stringify(config, null, 2),
+      tags: ['runtime-config']
+    })
+  }
+
+  updateRuntimeEnv (contents) {
+    this.addFile({
+      path: '',
+      file: '.env',
+      contents,
+      tags: ['runtime-env']
+    })
+  }
+
+  updateConfigEntryPoint (entrypoint) {
+    // This can return null if the generator was not supposed to modify the config
+    const configObject = this.getRuntimeConfigFileObject()
+    const config = JSON.parse(configObject.contents)
+    config.entrypoint = entrypoint
+
+    this.updateRuntimeConfig(config)
+  }
 }
 
 class WrappedGenerator extends BaseGenerator {

package/lib/prom-server.js

@@ -93,6 +93,29 @@ async function startPrometheusServer (runtime, opts) {
     onRequestHook = promServer.basicAuth
   }
 
+  const readinessEndpoint = opts.readiness?.endpoint ?? DEFAULT_READINESS_ENDPOINT
+  const livenessEndpoint = opts.liveness?.endpoint ?? DEFAULT_LIVENESS_ENDPOINT
+
+  promServer.route({
+    url: '/',
+    method: 'GET',
+    logLevel: 'warn',
+    handler (req, reply) {
+      reply.type('text/plain')
+      let response = `Hello from Platformatic Prometheus Server!\nThe metrics are available at ${metricsEndpoint}.`
+
+      if (opts.readiness !== false) {
+        response += `\nThe readiness endpoint is available at ${readinessEndpoint}.`
+      }
+
+      if (opts.liveness !== false) {
+        response += `\nThe liveness endpoint is available at ${livenessEndpoint}.`
+      }
+
+      return response
+    }
+  })
+
   promServer.route({
     url: metricsEndpoint,
     method: 'GET',
@@ -112,7 +135,7 @@ async function startPrometheusServer (runtime, opts) {
     const failBody = opts.readiness?.fail?.body ?? DEFAULT_READINESS_FAIL_BODY
 
     promServer.route({
-      url: opts.readiness?.endpoint ?? DEFAULT_READINESS_ENDPOINT,
+      url: readinessEndpoint,
       method: 'GET',
       logLevel: 'warn',
       handler: async (req, reply) => {
@@ -151,7 +174,7 @@ async function startPrometheusServer (runtime, opts) {
     const failBody = opts.liveness?.fail?.body ?? DEFAULT_LIVENESS_FAIL_BODY
 
     promServer.route({
-      url: opts.liveness?.endpoint ?? DEFAULT_LIVENESS_ENDPOINT,
+      url: livenessEndpoint,
       method: 'GET',
       logLevel: 'warn',
       handler: async (req, reply) => {

package/lib/runtime.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { ITC } = require('@platformatic/itc')
-const { ensureLoggableError, executeWithTimeout, deepmerge } = require('@platformatic/utils')
+const { features, ensureLoggableError, executeWithTimeout, deepmerge } = 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')
@@ -50,6 +50,7 @@ const COLLECT_METRICS_TIMEOUT = 1000
 
 const MAX_BOOTSTRAP_ATTEMPTS = 5
 const IMMEDIATE_RESTART_MAX_THRESHOLD = 10
+const MAX_WORKERS = 100
 
 const telemetryPath = require.resolve('@platformatic/telemetry')
 const openTelemetrySetupPath = join(telemetryPath, '..', 'lib', 'node-telemetry.js')
@@ -129,7 +130,19 @@ class Runtime extends EventEmitter {
 
     this.#isProduction = this.#configManager.args?.production ?? false
     this.#servicesIds = config.services.map(service => service.id)
-    this.#workers.configure(config.services, this.#configManager.current.workers, this.#isProduction)
+
+    const workersConfig = []
+    for (const service of config.services) {
+      const count = service.workers ?? this.#configManager.current.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}`)
+        workersConfig.push({ id: service.id, workers: 1 })
+      } else {
+        workersConfig.push({ id: service.id, workers: count })
+      }
+    }
+
+    this.#workers.configure(workersConfig)
 
     if (this.#isProduction) {
       this.#env['PLT_DEV'] = 'false'
@@ -198,17 +211,7 @@ class Runtime extends EventEmitter {
       await this.closeAndThrow(e)
     }
 
-    const dispatcherOpts = { ...config.undici }
-    const interceptors = [this.#meshInterceptor]
-
-    if (config.httpCache) {
-      this.#sharedHttpCache = await createSharedStore(this.#configManager.dirname, config.httpCache)
-      interceptors.push(
-        undiciInterceptors.cache({ store: this.#sharedHttpCache, methods: config.httpCache.methods ?? ['GET', 'HEAD'] })
-      )
-    }
-
-    this.#dispatcher = new Agent(dispatcherOpts).compose(interceptors)
+    await this.#setDispatcher(config.undici)
 
     if (config.scheduler) {
       this.#scheduler = startScheduler(config.scheduler, this.#dispatcher, logger)
@@ -477,6 +480,22 @@ class Runtime extends EventEmitter {
     }
   }
 
+  async updateUndiciInterceptors (undiciConfig) {
+    this.#configManager.current.undici = undiciConfig
+
+    const promises = []
+    for (const worker of this.#workers.values()) {
+      promises.push(sendViaITC(worker, 'updateUndiciInterceptors', undiciConfig))
+    }
+
+    const results = await Promise.allSettled(promises)
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        throw result.reason
+      }
+    }
+  }
+
   startCollectingMetrics () {
     this.#metrics = []
     this.#metricsTimeout = setInterval(async () => {
@@ -1041,6 +1060,24 @@ class Runtime extends EventEmitter {
     return super.emit(event, payload)
   }
 
+  async #setDispatcher (undiciConfig) {
+    const config = this.#configManager.current
+
+    const dispatcherOpts = { ...undiciConfig }
+    const interceptors = [this.#meshInterceptor]
+
+    if (config.httpCache) {
+      this.#sharedHttpCache = await createSharedStore(this.#configManager.dirname, config.httpCache)
+      interceptors.push(
+        undiciInterceptors.cache({
+          store: this.#sharedHttpCache,
+          methods: config.httpCache.methods ?? ['GET', 'HEAD']
+        })
+      )
+    }
+    this.#dispatcher = new Agent(dispatcherOpts).compose(interceptors)
+  }
+
   #updateStatus (status, args) {
     this.#status = status
     this.emit(status, args)
@@ -1279,7 +1316,7 @@ class Runtime extends EventEmitter {
     }
 
     // This must be done here as the dependencies are filled above
-    worker[kConfig] = { ...serviceConfig, health }
+    worker[kConfig] = { ...serviceConfig, health, workers: workersCount }
     worker[kWorkerStatus] = 'init'
     this.emit('service:worker:init', eventPayload)
 
@@ -1809,6 +1846,86 @@ class Runtime extends EventEmitter {
       await immediate()
     }
   }
+
+  async getServiceResourcesInfo (id) {
+    const workers = this.#workers.getCount(id)
+    return { workers }
+  }
+
+  async #updateWorkerCount (serviceId, workers) {
+    this.#configManager.current.services.find(s => s.id === serviceId).workers = workers
+    const service = await this.#getServiceById(serviceId)
+    this.#workers.setCount(serviceId, workers)
+    service[kConfig].workers = workers
+
+    const promises = []
+    for (const [workerId, worker] of this.#workers.entries()) {
+      if (workerId.startsWith(`${serviceId}:`)) {
+        promises.push(sendViaITC(worker, 'updateWorkersCount', { serviceId, workers }))
+      }
+    }
+
+    const results = await Promise.allSettled(promises)
+    for (const result of results) {
+      if (result.status === 'rejected') {
+        throw result.reason
+      }
+    }
+  }
+
+  async updateServicesResources (updates) {
+    if (this.#status === 'stopping' || this.#status === 'closed') return
+
+    if (!Array.isArray(updates)) {
+      throw new errors.InvalidArgumentError('updates', 'must be an array')
+    }
+    if (updates.length === 0) {
+      throw new errors.InvalidArgumentError('updates', 'must have at least one element')
+    }
+
+    const config = this.#configManager.current
+
+    for (const update of updates) {
+      const { service: serviceId, workers } = update
+
+      if (typeof workers !== 'number') {
+        throw new errors.InvalidArgumentError('workers', 'must be a number')
+      }
+      if (!serviceId) {
+        throw new errors.InvalidArgumentError('service', 'must be a string')
+      }
+      if (workers <= 0) {
+        throw new errors.InvalidArgumentError('workers', 'must be greater than 0')
+      }
+      if (workers > MAX_WORKERS) {
+        throw new errors.InvalidArgumentError('workers', `must be less than ${MAX_WORKERS}`)
+      }
+      const serviceConfig = config.services.find(s => s.id === serviceId)
+      if (!serviceConfig) {
+        throw new errors.ServiceNotFoundError(serviceId, Array.from(this.#servicesIds).join(', '))
+      }
+
+      const { workers: currentWorkers } = await this.getServiceResourcesInfo(serviceId)
+      if (currentWorkers === workers) {
+        this.logger.warn({ serviceId, workers }, 'No change in the number of workers for service')
+        continue
+      }
+
+      if (currentWorkers < workers) {
+        await this.#updateWorkerCount(serviceId, workers)
+        for (let i = currentWorkers; i < workers; i++) {
+          await this.#setupWorker(config, serviceConfig, workers, serviceId, i)
+          await this.#startWorker(config, serviceConfig, workers, serviceId, i, false, 0)
+        }
+      } else {
+        for (let i = currentWorkers - 1; i >= workers; i--) {
+          // keep the current workers count until the workers are stopped
+          await this.#stopWorker(currentWorkers, serviceId, i, false)
+        }
+        await this.#updateWorkerCount(serviceId, workers)
+      }
+    }
+  }
 }
 
 module.exports = { Runtime }

package/lib/worker/interceptors.js

@@ -1,19 +1,208 @@
 'use strict'
 
+const { join } = require('node:path')
+const { workerData, parentPort } = require('node:worker_threads')
 const { pathToFileURL } = require('node:url')
+const { createRequire } = require('@platformatic/utils')
+const { setGlobalDispatcher, Client, Pool, Agent } = require('undici')
+const { wire } = require('undici-thread-interceptor')
+const { createTelemetryThreadInterceptorHooks } = require('@platformatic/telemetry')
+const { RemoteCacheStore, httpCacheInterceptor } = require('./http-cache')
+const { kInterceptors } = require('./symbols')
 
-async function loadInterceptor (_require, module, options) {
-  const url = pathToFileURL(_require.resolve(module))
-  const interceptor = (await import(url)).default
-  return interceptor(options)
+async function setDispatcher (runtimeConfig) {
+  const threadDispatcher = createThreadInterceptor(runtimeConfig)
+  const threadInterceptor = threadDispatcher.interceptor
+
+  let cacheInterceptor = null
+  if (runtimeConfig.httpCache) {
+    cacheInterceptor = createHttpCacheInterceptor(runtimeConfig)
+  }
+
+  let userInterceptors = []
+  if (Array.isArray(runtimeConfig.undici?.interceptors)) {
+    const _require = createRequire(join(workerData.dirname, 'package.json'))
+    userInterceptors = await loadInterceptors(_require, runtimeConfig.undici.interceptors)
+  }
+
+  const dispatcherOpts = await getDispatcherOpts(runtimeConfig.undici)
+
+  setGlobalDispatcher(
+    new Agent(dispatcherOpts).compose(
+      [
+        threadInterceptor,
+        ...userInterceptors,
+        cacheInterceptor
+      ].filter(Boolean)
+    )
+  )
+
+  return { threadDispatcher }
+}
+
+async function updateUndiciInterceptors (undiciConfig) {
+  const updatableInterceptors = globalThis[kInterceptors]
+  if (!updatableInterceptors) return
+
+  if (Array.isArray(undiciConfig?.interceptors)) {
+    for (const interceptorConfig of undiciConfig.interceptors) {
+      const { module, options } = interceptorConfig
+
+      const interceptorCtx = updatableInterceptors[module]
+      if (!interceptorCtx) continue
+
+      const { createInterceptor, updateInterceptor } = interceptorCtx
+      updateInterceptor(createInterceptor(options))
+    }
+  } else {
+    for (const key of ['Agent', 'Pool', 'Client']) {
+      const interceptorConfigs = undiciConfig.interceptors[key]
+      if (!interceptorConfigs) continue
+
+      for (const interceptorConfig of interceptorConfigs) {
+        const { module, options } = interceptorConfig
+
+        const interceptorCtx = updatableInterceptors[key][module]
+        if (!interceptorCtx) continue
+
+        const { createInterceptor, updateInterceptor } = interceptorCtx
+        updateInterceptor(createInterceptor(options))
+      }
+    }
+  }
 }
 
-function loadInterceptors (_require, interceptors) {
+function createUpdatableInterceptor (originInterceptor) {
+  let originalDispatcher = null
+  let originalDispatch = null
+
+  function updatableInterceptor (dispatch) {
+    originalDispatch = dispatch
+    originalDispatcher = originInterceptor(dispatch)
+
+    return function dispatcher (opts, handler) {
+      return originalDispatcher(opts, handler)
+    }
+  }
+
+  function updateInterceptor (newInterceptor) {
+    originalDispatcher = newInterceptor(originalDispatch)
+  }
+
+  return { updatableInterceptor, updateInterceptor }
+}
+
+async function loadInterceptors (_require, interceptorsConfigs, key) {
   return Promise.all(
-    interceptors.map(async ({ module, options }) => {
-      return loadInterceptor(_require, module, options)
+    interceptorsConfigs.map(async (interceptorConfig) => {
+      return loadInterceptor(_require, interceptorConfig, key)
     })
   )
 }
 
-module.exports = { loadInterceptors }
+async function loadInterceptor (_require, interceptorConfig, key) {
+  let updatableInterceptors = globalThis[kInterceptors]
+  if (!updatableInterceptors) {
+    updatableInterceptors = {}
+    globalThis[kInterceptors] = updatableInterceptors
+  }
+
+  const { module, options } = interceptorConfig
+
+  const url = pathToFileURL(_require.resolve(module))
+  const createInterceptor = (await import(url)).default
+  const interceptor = createInterceptor(options)
+
+  const {
+    updatableInterceptor,
+    updateInterceptor
+  } = createUpdatableInterceptor(interceptor)
+
+  const interceptorCtx = { createInterceptor, updateInterceptor }
+
+  if (key !== undefined) {
+    if (!updatableInterceptors[key]) {
+      updatableInterceptors[key] = {}
+    }
+    updatableInterceptors[key][module] = interceptorCtx
+  } else {
+    updatableInterceptors[module] = interceptorCtx
+  }
+
+  return updatableInterceptor
+}
+
+async function getDispatcherOpts (undiciConfig) {
+  const dispatcherOpts = { ...undiciConfig }
+
+  const interceptorsConfigs = undiciConfig?.interceptors
+  if (!interceptorsConfigs || Array.isArray(interceptorsConfigs)) {
+    return dispatcherOpts
+  }
+
+  const _require = createRequire(join(workerData.dirname, 'package.json'))
+
+  const clientInterceptors = []
+  const poolInterceptors = []
+
+  for (const key of ['Agent', 'Pool', 'Client']) {
+    const interceptorConfig = undiciConfig.interceptors[key]
+    if (!interceptorConfig) continue
+
+    const interceptors = await loadInterceptors(_require, interceptorConfig, key)
+    if (key === 'Agent') {
+      clientInterceptors.push(...interceptors)
+      poolInterceptors.push(...interceptors)
+    }
+    if (key === 'Pool') {
+      poolInterceptors.push(...interceptors)
+    }
+    if (key === 'Client') {
+      clientInterceptors.push(...interceptors)
+    }
+  }
+
+  dispatcherOpts.factory = (origin, opts) => {
+    return opts && opts.connections === 1
+      ? new Client(origin, opts).compose(clientInterceptors)
+      : new Pool(origin, opts).compose(poolInterceptors)
+  }
+
+  return dispatcherOpts
+}
+
+function createThreadInterceptor (runtimeConfig) {
+  const telemetry = runtimeConfig.telemetry
+  const hooks = telemetry ? createTelemetryThreadInterceptorHooks() : {}
+  const threadDispatcher = wire({
+    // Specifying the domain is critical to avoid flooding the DNS
+    // with requests for a domain that's never going to exist.
+    domain: '.plt.local',
+    port: parentPort,
+    timeout: runtimeConfig.serviceTimeout,
+    ...hooks
+  })
+  return threadDispatcher
+}
+
+function createHttpCacheInterceptor (runtimeConfig) {
+  const cacheInterceptor = httpCacheInterceptor({
+    store: new RemoteCacheStore({
+      onRequest: opts => {
+        globalThis.platformatic?.onHttpCacheRequest?.(opts)
+      },
+      onCacheHit: opts => {
+        globalThis.platformatic?.onHttpCacheHit?.(opts)
+      },
+      onCacheMiss: opts => {
+        globalThis.platformatic?.onHttpCacheMiss?.(opts)
+      },
+      logger: globalThis.platformatic.logger
+    }),
+    methods: runtimeConfig.httpCache.methods ?? ['GET', 'HEAD'],
+    logger: globalThis.platformatic.logger
+  })
+  return cacheInterceptor
+}
+
+module.exports = { setDispatcher, updateUndiciInterceptors }

package/lib/worker/itc.js

@@ -1,12 +1,13 @@
 'use strict'
 
 const { once } = require('node:events')
-const { parentPort } = require('node:worker_threads')
+const { parentPort, workerData } = require('node:worker_threads')
 
 const { ITC } = require('@platformatic/itc')
 const { Unpromise } = require('@watchable/unpromise')
 
 const errors = require('../errors')
+const { updateUndiciInterceptors } = require('./interceptors')
 const { kITC, kId, kServiceId, kWorkerId } = require('./symbols')
 
 async function safeHandleInITC (worker, fn) {
@@ -109,6 +110,18 @@ function setupITC (app, service, dispatcher) {
         return app.stackable.inject(injectParams)
       },
 
+      async updateUndiciInterceptors (undiciConfig) {
+        await updateUndiciInterceptors(undiciConfig)
+      },
+
+      async updateWorkersCount (data) {
+        const { serviceId, workers } = data
+        const w = workerData.config.serviceMap.get(serviceId)
+        if (w) { w.workers = workers }
+        workerData.serviceConfig.workers = workers
+        workerData.worker.count = workers
+      },
+
       getStatus () {
         return app.getStatus()
       },

package/lib/worker/main.js

@@ -2,16 +2,14 @@
 
 const { EventEmitter } = require('node:events')
 const { hostname } = require('node:os')
-const { join, resolve } = require('node:path')
-const { parentPort, workerData, threadId } = require('node:worker_threads')
+const { resolve } = require('node:path')
+const { workerData, threadId } = require('node:worker_threads')
 const { pathToFileURL } = require('node:url')
 const inspector = require('node:inspector')
 const diagnosticChannel = require('node:diagnostics_channel')
 const { ServerResponse } = require('node:http')
 
-const { createTelemetryThreadInterceptorHooks } = require('@platformatic/telemetry')
 const {
-  createRequire,
   disablePinoDirectWrite,
   ensureFlushedWorkerStdio,
   executeWithTimeout,
@@ -22,14 +20,11 @@ const {
 } = require('@platformatic/utils')
 const dotenv = require('dotenv')
 const pino = require('pino')
-const { fetch, setGlobalDispatcher, getGlobalDispatcher, Agent } = require('undici')
-const { wire } = require('undici-thread-interceptor')
-const undici = require('undici')
+const { fetch } = require('undici')
 
-const { RemoteCacheStore, httpCacheInterceptor } = require('./http-cache')
 const { PlatformaticApp } = require('./app')
 const { setupITC } = require('./itc')
-const { loadInterceptors } = require('./interceptors')
+const { setDispatcher } = require('./interceptors')
 const { kId, kITC, kStderrMarker } = require('./symbols')
 
 function handleUnhandled (app, type, err) {
@@ -138,85 +133,7 @@ async function main () {
     Object.assign(process.env, service.env)
   }
 
-  // Setup undici
-  const interceptors = {}
-  const composedInterceptors = []
-
-  if (config.undici?.interceptors) {
-    const _require = createRequire(join(workerData.dirname, 'package.json'))
-    for (const key of ['Agent', 'Pool', 'Client']) {
-      if (config.undici.interceptors[key]) {
-        interceptors[key] = await loadInterceptors(_require, config.undici.interceptors[key])
-      }
-    }
-
-    if (Array.isArray(config.undici.interceptors)) {
-      composedInterceptors.push(...(await loadInterceptors(_require, config.undici.interceptors)))
-    }
-  }
-
-  const dispatcherOpts = { ...config.undici }
-
-  if (Object.keys(interceptors).length > 0) {
-    const clientInterceptors = []
-    const poolInterceptors = []
-
-    if (interceptors.Agent) {
-      clientInterceptors.push(...interceptors.Agent)
-      poolInterceptors.push(...interceptors.Agent)
-    }
-
-    if (interceptors.Pool) {
-      poolInterceptors.push(...interceptors.Pool)
-    }
-
-    if (interceptors.Client) {
-      clientInterceptors.push(...interceptors.Client)
-    }
-
-    dispatcherOpts.factory = (origin, opts) => {
-      return opts && opts.connections === 1
-        ? new undici.Client(origin, opts).compose(clientInterceptors)
-        : new undici.Pool(origin, opts).compose(poolInterceptors)
-    }
-  }
-
-  setGlobalDispatcher(new Agent(dispatcherOpts))
-
-  const { telemetry } = service
-  const hooks = telemetry ? createTelemetryThreadInterceptorHooks() : {}
-  // Setup mesh networker
-  const threadDispatcher = wire({
-    // Specifying the domain is critical to avoid flooding the DNS
-    // with requests for a domain that's never going to exist.
-    domain: '.plt.local',
-    port: parentPort,
-    timeout: config.serviceTimeout,
-    ...hooks
-  })
-
-  if (config.httpCache) {
-    const cacheInterceptor = httpCacheInterceptor({
-      store: new RemoteCacheStore({
-        onRequest: opts => {
-          globalThis.platformatic?.onHttpCacheRequest?.(opts)
-        },
-        onCacheHit: opts => {
-          globalThis.platformatic?.onHttpCacheHit?.(opts)
-        },
-        onCacheMiss: opts => {
-          globalThis.platformatic?.onHttpCacheMiss?.(opts)
-        },
-        logger: globalThis.platformatic.logger
-      }),
-      methods: config.httpCache.methods ?? ['GET', 'HEAD'],
-      logger: globalThis.platformatic.logger
-    })
-    composedInterceptors.push(cacheInterceptor)
-  }
-
-  const globalDispatcher = getGlobalDispatcher()
-  setGlobalDispatcher(globalDispatcher.compose(composedInterceptors))
+  const { threadDispatcher } = await setDispatcher(config)
 
   // If the service is an entrypoint and runtime server config is defined, use it.
   let serverConfig = null

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

@@ -1,7 +1,5 @@
 'use strict'
 
-const { features } = require('@platformatic/utils')
-
 class RoundRobinMap extends Map {
   #instances
 
@@ -14,18 +12,11 @@ class RoundRobinMap extends Map {
     return { ...this.#instances }
   }
 
-  // In development or for the entrypoint always use 1 worker
-  configure (services, defaultInstances, production) {
+  configure (services) {
     this.#instances = {}
 
     for (const service of services) {
-      let count = service.workers ?? defaultInstances
-
-      if (!production || (service.entrypoint && !features.node.reusePort)) {
-        count = 1
-      }
-
-      this.#instances[service.id] = { next: 0, count }
+      this.#instances[service.id] = { next: 0, count: service.workers }
     }
   }
 
@@ -33,6 +24,10 @@ class RoundRobinMap extends Map {
     return this.#instances[service].count
   }
 
+  setCount (service, count) {
+    this.#instances[service].count = count
+  }
+
   next (service) {
     if (!this.#instances[service]) {
       return undefined

package/lib/worker/symbols.js

@@ -8,6 +8,7 @@ const kWorkerId = Symbol.for('plt.runtime.worker.id')
 const kITC = Symbol.for('plt.runtime.itc')
 const kHealthCheckTimer = Symbol.for('plt.runtime.worker.healthCheckTimer')
 const kWorkerStatus = Symbol('plt.runtime.worker.status')
+const kInterceptors = Symbol.for('plt.runtime.worker.interceptors')
 
 // This string marker should be safe to use since it belongs to Unicode private area
 const kStderrMarker = '\ue002'
@@ -21,5 +22,6 @@ module.exports = {
   kITC,
   kHealthCheckTimer,
   kWorkerStatus,
-  kStderrMarker
+  kStderrMarker,
+  kInterceptors
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "2.67.0-alpha.1",
+  "version": "2.67.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -37,12 +37,12 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "2.67.0-alpha.1",
-    "@platformatic/db": "2.67.0-alpha.1",
-    "@platformatic/node": "2.67.0-alpha.1",
-    "@platformatic/service": "2.67.0-alpha.1",
-    "@platformatic/sql-graphql": "2.67.0-alpha.1",
-    "@platformatic/sql-mapper": "2.67.0-alpha.1"
+    "@platformatic/composer": "2.67.0",
+    "@platformatic/db": "2.67.0",
+    "@platformatic/node": "2.67.0",
+    "@platformatic/service": "2.67.0",
+    "@platformatic/sql-mapper": "2.67.0",
+    "@platformatic/sql-graphql": "2.67.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -77,21 +77,21 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.13.1",
     "ws": "^8.16.0",
-    "@platformatic/basic": "2.67.0-alpha.1",
-    "@platformatic/config": "2.67.0-alpha.1",
-    "@platformatic/generators": "2.67.0-alpha.1",
-    "@platformatic/itc": "2.67.0-alpha.1",
-    "@platformatic/telemetry": "2.67.0-alpha.1",
-    "@platformatic/ts-compiler": "2.67.0-alpha.1",
-    "@platformatic/utils": "2.67.0-alpha.1"
+    "@platformatic/basic": "2.67.0",
+    "@platformatic/config": "2.67.0",
+    "@platformatic/generators": "2.67.0",
+    "@platformatic/itc": "2.67.0",
+    "@platformatic/telemetry": "2.67.0",
+    "@platformatic/ts-compiler": "2.67.0",
+    "@platformatic/utils": "2.67.0"
   },
   "scripts": {
-    "test": "pnpm run lint && borp --concurrency=1 --timeout=300000 && tsd",
+    "test": "pnpm run lint && borp --concurrency=1 --timeout=600000 && tsd",
     "test:main": "borp --concurrency=1 --timeout=300000 test/*.test.js test/*.test.mjs test/versions/*.test.js test/versions/*.test.mjs",
     "test:api": "borp --concurrency=1 --timeout=300000 test/api/*.test.js test/api/*.test.mjs test/management-api/*.test.js test/management-api/*.test.mjs",
     "test:cli": "borp --concurrency=1 --timeout=300000 test/cli/*.test.js test/cli/*.test.mjs test/cli/**/*.test.js test/cli/**/*.test.mjs",
     "test:start": "borp --concurrency=1 --timeout=300000 test/start/*.test.js test/start/*.test.mjs",
-    "test:multiple-workers": "borp --concurrency=1 --timeout=300000 test/multiple-workers/*.test.js test/multiple-workers/*.test.mjs",
+    "test:multiple-workers": "borp --concurrency=1 --timeout=600000 test/multiple-workers/*.test.js test/multiple-workers/*.test.mjs",
     "test:types": "tsd",
     "coverage": "pnpm run lint && borp -X fixtures -X test -C --concurrency=1 --timeout=300000 && tsd",
     "gen-schema": "node lib/schema.js > schema.json",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.67.0-alpha.1.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.67.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
   "properties": {

package/undefined

@@ -1,5 +0,0 @@
-{"level":30,"time":1747909640025,"pid":84550,"hostname":"work","msg":"Starting the service \"service\"..."}
-{"level":30,"time":1747909640055,"pid":84550,"hostname":"work","msg":"Started the service \"service\"..."}
-{"level":30,"time":1747909640055,"pid":84550,"hostname":"work","msg":"Platformatic is now listening at http://127.0.0.1:41619"}
-{"level":30,"time":1747909640066,"pid":84550,"hostname":"work","msg":"Stopping the service \"service\"..."}
-{"level":30,"time":1747909640069,"pid":84550,"hostname":"work","msg":"Stopped the service \"service\"..."}