@platformatic/runtime 2.66.0 → 2.67.0-alpha.0

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export type HttpsSchemasPlatformaticDevPlatformaticRuntime2660Json = {
+export type HttpsSchemasPlatformaticDevPlatformaticRuntime2670Alpha0Json = {
   [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')
@@ -263,11 +263,16 @@ async function wrapConfigInRuntimeConfig ({ configManager, args }) {
     // on purpose, the package.json might be missing
   }
 
+  // If the service supports its (so far, only @platformatic/service and descendants)
+  const { hostname, port, http2, https } = configManager.current.server ?? {}
+  const server = { hostname, port, http2, https }
+
   // Important: do not change the order of the properties in this object
   /* c8 ignore next */
   const wrapperConfig = {
     $schema: schema.$id,
-    watch: true,
+    server,
+    watch: !args?.production,
     ...omitProperties(configManager.current.runtime ?? {}, runtimeUnwrappablePropertiesList),
     entrypoint: serviceId,
     services: [
@@ -293,7 +298,7 @@ async function wrapConfigInRuntimeConfig ({ configManager, args }) {
     }
   })
 
-  await cm.parseAndValidate()
+  await cm.parseAndValidate(true, [], opts)
 
   return cm
 }

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

@@ -198,17 +198,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 +467,24 @@ class Runtime extends EventEmitter {
     }
   }
 
+  async updateUndiciConfig (undiciConfig) {
+    this.#configManager.current.undici = undiciConfig
+
+    await this.#setDispatcher(undiciConfig)
+
+    const promises = []
+    for (const worker of this.#workers.values()) {
+      promises.push(sendViaITC(worker, 'updateUndiciConfig', 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 +1049,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)

package/lib/start.js

@@ -91,16 +91,29 @@ async function setupAndStartRuntime (config) {
 
   let address = null
   const startErr = null
-  const originalPort = runtimeConfig.current.server?.port || 0
+
+  runtimeConfig.current.server ??= { port: 0 }
+  let port = runtimeConfig.current.server.port
   while (address === null) {
     try {
       address = await runtime.start()
     } catch (err) {
       if (err.code === 'EADDRINUSE') {
+        // Get the actual port from the error message if original port was 0
+        if (!port) {
+          const mo = err.message.match(/ address already in use (.+)/)
+          const url = new URL(`http://${mo[1]}`)
+          port = Number(url.port)
+        }
+
+        port++
         await runtime.close()
 
-        if (runtimeConfig.current?.server?.port > MAX_PORT) throw err
-        runtimeConfig.current.server.port++
+        if (port > MAX_PORT) {
+          throw err
+        }
+
+        runtimeConfig.current.server.port = port
         runtime = await buildRuntime(runtimeConfig)
       } else {
         throw err
@@ -114,7 +127,7 @@ async function setupAndStartRuntime (config) {
         ignore: 'hostname,pid'
       })
     )
-    logger.warn(`Port: ${originalPort} is already in use!`)
+    logger.warn(`Port: ${port} is already in use!`)
     logger.warn(`Changing the port to ${runtimeConfig.current.server.port}`)
   }
   return { address, runtime }

package/lib/worker/interceptors.js

@@ -1,6 +1,128 @@
 '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 setDispatcher (runtimeConfig) {
+  const dispatcherOpts = await getDespatcherOpts(runtimeConfig.undici)
+
+  let interceptors = globalThis[kInterceptors]
+  if (!interceptors) {
+    const threadDispatcher = createThreadInterceptor(runtimeConfig)
+    const threadInterceptor = threadDispatcher.interceptor
+
+    let cacheInterceptor = null
+    if (runtimeConfig.httpCache) {
+      cacheInterceptor = createHttpCacheInterceptor(runtimeConfig)
+    }
+
+    interceptors = {
+      threadDispatcher,
+      threadInterceptor,
+      cacheInterceptor
+    }
+
+    globalThis[kInterceptors] = interceptors
+  }
+
+  let userInterceptors = []
+  if (Array.isArray(runtimeConfig.undici?.interceptors)) {
+    const _require = createRequire(join(workerData.dirname, 'package.json'))
+    userInterceptors = await loadInterceptors(_require, runtimeConfig.undici.interceptors)
+  }
+
+  setGlobalDispatcher(
+    new Agent(dispatcherOpts).compose(
+      [
+        interceptors.threadInterceptor,
+        interceptors.cacheInterceptor,
+        ...userInterceptors
+      ].filter(Boolean)
+    )
+  )
+
+  return interceptors
+}
+
+async function getDespatcherOpts (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)
+    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
+}
 
 async function loadInterceptor (_require, module, options) {
   const url = pathToFileURL(_require.resolve(module))
@@ -16,4 +138,4 @@ function loadInterceptors (_require, interceptors) {
   )
 }
 
-module.exports = { loadInterceptors }
+module.exports = { setDispatcher }

package/lib/worker/itc.js

@@ -7,6 +7,7 @@ const { ITC } = require('@platformatic/itc')
 const { Unpromise } = require('@watchable/unpromise')
 
 const errors = require('../errors')
+const { setDispatcher } = require('./interceptors')
 const { kITC, kId, kServiceId, kWorkerId } = require('./symbols')
 
 async function safeHandleInITC (worker, fn) {
@@ -109,6 +110,11 @@ function setupITC (app, service, dispatcher) {
         return app.stackable.inject(injectParams)
       },
 
+      async updateUndiciConfig (undiciConfig) {
+        const config = await app.stackable.getConfig()
+        await setDispatcher({ ...config, undici: undiciConfig })
+      },
+
       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/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.66.0",
+  "version": "2.67.0-alpha.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.66.0",
-    "@platformatic/db": "2.66.0",
-    "@platformatic/node": "2.66.0",
-    "@platformatic/service": "2.66.0",
-    "@platformatic/sql-mapper": "2.66.0",
-    "@platformatic/sql-graphql": "2.66.0"
+    "@platformatic/composer": "2.67.0-alpha.0",
+    "@platformatic/db": "2.67.0-alpha.0",
+    "@platformatic/node": "2.67.0-alpha.0",
+    "@platformatic/service": "2.67.0-alpha.0",
+    "@platformatic/sql-graphql": "2.67.0-alpha.0",
+    "@platformatic/sql-mapper": "2.67.0-alpha.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -77,13 +77,13 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^0.13.1",
     "ws": "^8.16.0",
-    "@platformatic/basic": "2.66.0",
-    "@platformatic/generators": "2.66.0",
-    "@platformatic/config": "2.66.0",
-    "@platformatic/itc": "2.66.0",
-    "@platformatic/ts-compiler": "2.66.0",
-    "@platformatic/telemetry": "2.66.0",
-    "@platformatic/utils": "2.66.0"
+    "@platformatic/basic": "2.67.0-alpha.0",
+    "@platformatic/config": "2.67.0-alpha.0",
+    "@platformatic/generators": "2.67.0-alpha.0",
+    "@platformatic/itc": "2.67.0-alpha.0",
+    "@platformatic/telemetry": "2.67.0-alpha.0",
+    "@platformatic/utils": "2.67.0-alpha.0",
+    "@platformatic/ts-compiler": "2.67.0-alpha.0"
   },
   "scripts": {
     "test": "pnpm run lint && borp --concurrency=1 --timeout=300000 && tsd",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.66.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/2.67.0-alpha.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\"..."}