@platformatic/basic 2.6.1 → 2.8.0-alpha.1

package/index.js

@@ -110,7 +110,8 @@ async function buildStackable (opts) {
   const serviceRoot = relative(process.cwd(), opts.context.directory)
   if (
     !hadConfig &&
-    !existsSync(resolve(serviceRoot, 'platformatic.json') || existsSync(resolve(serviceRoot, 'watt.json')))
+    !existsSync(resolve(serviceRoot, 'platformatic.json') || existsSync(resolve(serviceRoot, 'watt.json'))) &&
+    opts.context.worker?.count > 1
   ) {
     const logger = pino({
       level: opts.context.serverConfig?.logger?.level ?? 'warn',
@@ -119,7 +120,7 @@ async function buildStackable (opts) {
 
     logger.warn(
       [
-        `Platformatic has auto-detected that service ${opts.context.serviceId} ${autodetectDescription}.\n`,
+        `Platformatic has auto-detected that service "${opts.context.serviceId}" ${autodetectDescription}.\n`,
         `We suggest you create a platformatic.json or watt.json file in the folder ${serviceRoot} with the "$schema" `,
         `property set to "https://schemas.platformatic.dev/${toImport}/${packageJson.version}.json".`
       ].join('')

package/lib/base.js

@@ -1,11 +1,12 @@
-import { deepmerge } from '@platformatic/utils'
 import { collectMetrics } from '@platformatic/metrics'
+import { deepmerge, executeWithTimeout } from '@platformatic/utils'
 import { parseCommandString } from 'execa'
 import { spawn } from 'node:child_process'
 import { once } from 'node:events'
 import { existsSync } from 'node:fs'
-import { platform } from 'node:os'
+import { hostname, platform } from 'node:os'
 import { pathToFileURL } from 'node:url'
+import { workerData } from 'node:worker_threads'
 import pino from 'pino'
 import split2 from 'split2'
 import { NonZeroExitCode } from './errors.js'
@@ -18,9 +19,12 @@ export class BaseStackable {
   #subprocessStarted
 
   constructor (type, version, options, root, configManager) {
+    options.context.worker ??= { count: 1, index: 0 }
+
     this.type = type
     this.version = version
-    this.id = options.context.serviceId
+    this.serviceId = options.context.serviceId
+    this.workerId = options.context.worker.count > 1 ? options.context.worker.index : undefined
     this.telemetryConfig = options.context.telemetryConfig
     this.options = options
     this.root = root
@@ -34,19 +38,30 @@ export class BaseStackable {
     this.startHttpTimer = null
     this.endHttpTimer = null
     this.clientWs = null
+    this.runtimeConfig = workerData?.config ?? null
 
     // Setup the logger
     const pinoOptions = {
-      level: this.serverConfig?.logger?.level ?? 'trace'
+      level: this.configManager.current?.logger?.level ?? this.serverConfig?.logger?.level ?? 'trace'
+    }
+
+    if (this.serviceId) {
+      pinoOptions.name = this.serviceId
     }
 
-    if (this.id) {
-      pinoOptions.name = this.id
+    if (typeof options.context.worker?.index !== 'undefined') {
+      pinoOptions.base = { pid: process.pid, hostname: hostname(), worker: this.workerId }
     }
+
     this.logger = pino(pinoOptions)
 
     // Setup globals
     this.registerGlobals({
+      serviceId: this.serviceId,
+      workerId: this.workerId,
+      logLevel: this.logger.level,
+      // Always use URL to avoid serialization problem in Windows
+      root: pathToFileURL(this.root).toString(),
       setOpenapiSchema: this.setOpenapiSchema.bind(this),
       setGraphqlSchema: this.setGraphqlSchema.bind(this),
       setBasePath: this.setBasePath.bind(this)
@@ -134,20 +149,12 @@ export class BaseStackable {
 
     this.logger.debug(`Executing "${command}" ...`)
 
+    const context = await this.#getChildManagerContext(basePath)
     this.childManager = new ChildManager({
       logger: this.logger,
       loader,
       scripts,
-      context: {
-        id: this.id,
-        // Always use URL to avoid serialization problem in Windows
-        root: pathToFileURL(this.root).toString(),
-        basePath,
-        logLevel: this.logger.level,
-        /* c8 ignore next 2 */
-        port: (this.isEntrypoint ? this.serverConfig?.port || 0 : undefined) ?? true,
-        host: (this.isEntrypoint ? this.serverConfig?.hostname : undefined) ?? true
-      }
+      context
     })
 
     try {
@@ -188,20 +195,12 @@ export class BaseStackable {
   async startWithCommand (command, loader) {
     const config = this.configManager.current
     const basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
+
+    const context = await this.#getChildManagerContext(basePath)
     this.childManager = new ChildManager({
       logger: this.logger,
       loader,
-      context: {
-        id: this.id,
-        // Always use URL to avoid serialization problem in Windows
-        root: pathToFileURL(this.root).toString(),
-        basePath,
-        logLevel: this.logger.level,
-        /* c8 ignore next 2 */
-        port: (this.isEntrypoint ? this.serverConfig?.port || 0 : undefined) ?? true,
-        host: (this.isEntrypoint ? this.serverConfig?.hostname : undefined) ?? true,
-        telemetry: this.telemetryConfig
-      }
+      context
     })
 
     this.childManager.on('config', config => {
@@ -255,9 +254,26 @@ export class BaseStackable {
     this.#subprocessStarted = false
     const exitPromise = once(this.subprocess, 'exit')
 
-    this.childManager.close(this.subprocessTerminationSignal ?? 'SIGINT')
-    this.subprocess.kill(this.subprocessTerminationSignal ?? 'SIGINT')
+    // Attempt graceful close on the process
+    this.childManager.notify(this.clientWs, 'close')
+
+    // If the process hasn't exited in 10 seconds, kill it in the polite way
+    /* c8 ignore next 10 */
+    const res = await executeWithTimeout(exitPromise, 10000)
+    if (res === 'timeout') {
+      this.subprocess.kill(this.subprocessTerminationSignal ?? 'SIGINT')
+
+      // If the process hasn't exited in 10 seconds, kill it the hard way
+      const res = await executeWithTimeout(exitPromise, 10000)
+      if (res === 'timeout') {
+        this.subprocess.kill('SIGKILL')
+      }
+    }
+
     await exitPromise
+
+    // Close the manager
+    this.childManager.close()
   }
 
   getChildManager () {
@@ -284,14 +300,16 @@ export class BaseStackable {
 
       if (this.childManager && this.clientWs) {
         await this.childManager.send(this.clientWs, 'collectMetrics', {
-          serviceId: this.id,
+          serviceId: this.serviceId,
+          workerId: this.workerId,
           metricsConfig
         })
         return
       }
 
       const { registry, startHttpTimer, endHttpTimer } = await collectMetrics(
-        this.id,
+        this.serviceId,
+        this.workerId,
         metricsConfig
       )
 
@@ -308,8 +326,35 @@ export class BaseStackable {
 
     if (!this.metricsRegistry) return null
 
-    return format === 'json'
-      ? await this.metricsRegistry.getMetricsAsJSON()
-      : await this.metricsRegistry.metrics()
+    return format === 'json' ? await this.metricsRegistry.getMetricsAsJSON() : await this.metricsRegistry.metrics()
+  }
+
+  getMeta () {
+    return {
+      composer: {
+        wantsAbsoluteUrls: false
+      }
+    }
+  }
+
+  async #getChildManagerContext (basePath) {
+    const meta = await this.getMeta()
+
+    return {
+      id: this.id,
+      serviceId: this.serviceId,
+      workerId: this.workerId,
+      // Always use URL to avoid serialization problem in Windows
+      root: pathToFileURL(this.root).toString(),
+      basePath,
+      logLevel: this.logger.level,
+      isEntrypoint: this.isEntrypoint,
+      runtimeBasePath: this.runtimeConfig?.basePath ?? null,
+      wantsAbsoluteUrls: meta.composer?.wantsAbsoluteUrls ?? false,
+      /* c8 ignore next 2 */
+      port: (this.isEntrypoint ? this.serverConfig?.port || 0 : undefined) ?? true,
+      host: (this.isEntrypoint ? this.serverConfig?.hostname : undefined) ?? true,
+      telemetry: this.telemetryConfig
+    }
   }
 }

package/lib/worker/child-manager.js

@@ -1,4 +1,4 @@
-import { ITC, generateNotification } from '@platformatic/itc'
+import { ITC } from '@platformatic/itc'
 import { createDirectory, ensureLoggableError } from '@platformatic/utils'
 import { once } from 'node:events'
 import { rm, writeFile } from 'node:fs/promises'
@@ -128,16 +128,11 @@ export class ChildManager extends ITC {
     })
   }
 
-  async close (signal) {
+  async close () {
     if (this.#dataPath) {
       await rm(this.#dataPath, { force: true })
     }
 
-    for (const client of this.#clients) {
-      this.#currentClient = client
-      this._send(generateNotification('close', signal))
-    }
-
     this.#server?.close()
     super.close()
   }
@@ -195,6 +190,11 @@ export class ChildManager extends ITC {
     return super.send(name, message)
   }
 
+  notify (client, name, message) {
+    this.#currentClient = client
+    return super.notify(name, message)
+  }
+
   _send (message, stringify = true) {
     if (!this.#currentClient) {
       this.#currentClient = this.#requests.get(message.reqId)

package/lib/worker/child-process.js

@@ -1,12 +1,13 @@
 import { ITC } from '@platformatic/itc'
+import { collectMetrics } from '@platformatic/metrics'
 import { setupNodeHTTPTelemetry } from '@platformatic/telemetry'
 import { createPinoWritable, ensureLoggableError } from '@platformatic/utils'
-import { collectMetrics } from '@platformatic/metrics'
-import { tracingChannel } from 'node:diagnostics_channel'
-import { once } from 'node:events'
+import diagnosticChannel, { tracingChannel } from 'node:diagnostics_channel'
+import { EventEmitter, once } from 'node:events'
 import { readFile } from 'node:fs/promises'
+import { ServerResponse } from 'node:http'
 import { register } from 'node:module'
-import { platform, tmpdir } from 'node:os'
+import { hostname, platform, tmpdir } from 'node:os'
 import { basename, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { isMainThread } from 'node:worker_threads'
@@ -15,7 +16,9 @@ import { getGlobalDispatcher, setGlobalDispatcher } from 'undici'
 import { WebSocket } from 'ws'
 import { exitCodes } from '../errors.js'
 import { importFile } from '../utils.js'
-import { getSocketPath, isWindows } from './child-manager.js'
+import { getSocketPath } from './child-manager.js'
+
+const windowsNpmExecutables = ['npm-prefix.js', 'npm-cli.js']
 
 function createInterceptor (itc) {
   return function (dispatch) {
@@ -95,7 +98,7 @@ export class ChildProcess extends ITC {
         },
         getMetrics: (...args) => {
           return this.#getMetrics(...args)
-        },
+        }
       }
     })
 
@@ -111,8 +114,11 @@ export class ChildProcess extends ITC {
     this.#setupServer()
     this.#setupInterceptors()
 
-    this.on('close', signal => {
-      process.kill(process.pid, signal)
+    this.on('close', () => {
+      if (!globalThis.platformatic.events.emit('close')) {
+        // No user event, just exit without errors
+        process.exit(0)
+      }
     })
   }
 
@@ -165,17 +171,16 @@ export class ChildProcess extends ITC {
     this.#socket.close()
   }
 
-  async #collectMetrics ({ serviceId, metricsConfig }) {
-    const { registry } = await collectMetrics(serviceId, metricsConfig)
+  async #collectMetrics ({ serviceId, workerId, metricsConfig }) {
+    const { registry } = await collectMetrics(serviceId, workerId, metricsConfig)
     this.#metricsRegistry = registry
   }
 
   async #getMetrics ({ format } = {}) {
     if (!this.#metricsRegistry) return null
 
-    const res = format === 'json'
-      ? await this.#metricsRegistry.getMetricsAsJSON()
-      : await this.#metricsRegistry.metrics()
+    const res =
+      format === 'json' ? await this.#metricsRegistry.getMetricsAsJSON() : await this.#metricsRegistry.metrics()
 
     return res
   }
@@ -183,20 +188,30 @@ export class ChildProcess extends ITC {
   #setupLogger () {
     // Since this is executed by user code, make sure we only override this in the main thread
     // The rest will be intercepted by the BaseStackable.
+    const pinoOptions = {
+      level: 'info',
+      name: globalThis.platformatic.serviceId
+    }
+
+    if (typeof globalThis.platformatic.workerId !== 'undefined') {
+      pinoOptions.base = {
+        pid: process.pid,
+        hostname: hostname(),
+        worker: parseInt(globalThis.platformatic.workerId)
+      }
+    }
+
     if (isMainThread) {
-      this.#logger = pino({
-        level: 'info',
-        name: globalThis.platformatic.id,
-        transport: {
-          target: new URL('./child-transport.js', import.meta.url).toString(),
-          options: { id: globalThis.platformatic.id }
-        }
-      })
+      pinoOptions.transport = {
+        target: new URL('./child-transport.js', import.meta.url).toString()
+      }
+
+      this.#logger = pino(pinoOptions)
 
       Reflect.defineProperty(process, 'stdout', { value: createPinoWritable(this.#logger, 'info') })
       Reflect.defineProperty(process, 'stderr', { value: createPinoWritable(this.#logger, 'error', true) })
     } else {
-      this.#logger = pino({ level: 'info', name: globalThis.platformatic.id })
+      this.#logger = pino(pinoOptions)
     }
   }
 
@@ -248,6 +263,11 @@ export class ChildProcess extends ITC {
     }
 
     tracingChannel('net.server.listen').subscribe(subscribers)
+
+    const { isEntrypoint, runtimeBasePath, wantsAbsoluteUrls } = globalThis.platformatic
+    if (isEntrypoint && runtimeBasePath && !wantsAbsoluteUrls) {
+      stripBasePath(runtimeBasePath)
+    }
   }
 
   #setupInterceptors () {
@@ -255,11 +275,13 @@ export class ChildProcess extends ITC {
   }
 
   #setupHandlers () {
+    const errorLabel =
+      typeof globalThis.platformatic.workerId !== 'undefined'
+        ? `worker ${globalThis.platformatic.workerId} of the service "${globalThis.platformatic.serviceId}"`
+        : `service "${globalThis.platformatic.serviceId}"`
+
     function handleUnhandled (type, err) {
-      this.#logger.error(
-        { err: ensureLoggableError(err) },
-        `Child process for service ${globalThis.platformatic.id} threw an ${type}.`
-      )
+      this.#logger.error({ err: ensureLoggableError(err) }, `Child process for the ${errorLabel} threw an ${type}.`)
 
       // Give some time to the logger and ITC notifications to land before shutting down
       setTimeout(() => process.exit(exitCodes.PROCESS_UNHANDLED_ERROR), 100)
@@ -270,11 +292,64 @@ export class ChildProcess extends ITC {
   }
 }
 
+function stripBasePath (basePath) {
+  const kBasePath = Symbol('kBasePath')
+
+  diagnosticChannel.subscribe('http.server.request.start', ({ request, response }) => {
+    if (request.url.startsWith(basePath)) {
+      request.url = request.url.slice(basePath.length)
+
+      if (request.url.charAt(0) !== '/') {
+        request.url = '/' + request.url
+      }
+
+      response[kBasePath] = basePath
+    }
+  })
+
+  const originWriteHead = ServerResponse.prototype.writeHead
+  const originSetHeader = ServerResponse.prototype.setHeader
+
+  ServerResponse.prototype.writeHead = function (statusCode, statusMessage, headers) {
+    if (this[kBasePath] !== undefined) {
+      if (headers === undefined && typeof statusMessage === 'object') {
+        headers = statusMessage
+        statusMessage = undefined
+      }
+
+      if (headers) {
+        for (const key in headers) {
+          if (key.toLowerCase() === 'location' && !headers[key].startsWith(basePath)) {
+            headers[key] = basePath + headers[key]
+          }
+        }
+      }
+    }
+
+    return originWriteHead.call(this, statusCode, statusMessage, headers)
+  }
+
+  ServerResponse.prototype.setHeader = function (name, value) {
+    if (this[kBasePath]) {
+      if (name.toLowerCase() === 'location' && !value.startsWith(basePath)) {
+        value = basePath + value
+      }
+    }
+    originSetHeader.call(this, name, value)
+  }
+}
+
 async function main () {
+  const executable = basename(process.argv[1] ?? '')
+  if (!isMainThread || windowsNpmExecutables.includes(executable)) {
+    return
+  }
+
   const dataPath = resolve(tmpdir(), 'platformatic', 'runtimes', `${process.env.PLT_MANAGER_ID}.json`)
   const { data, loader, scripts } = JSON.parse(await readFile(dataPath))
 
   globalThis.platformatic = data
+  globalThis.platformatic.events = new EventEmitter()
 
   if (data.root && isMainThread) {
     process.chdir(fileURLToPath(data.root))
@@ -291,7 +366,4 @@ async function main () {
   globalThis[Symbol.for('plt.children.itc')] = new ChildProcess()
 }
 
-/* c8 ignore next 3 */
-if (!isWindows || basename(process.argv.at(-1)) !== 'npm-prefix.js') {
-  await main()
-}
+await main()

package/lib/worker/child-transport.js

@@ -23,7 +23,7 @@ function handleUnhandled (type, error) {
 process.on('uncaughtException', handleUnhandled.bind(null, 'uncaught exception'))
 process.on('unhandledRejection', handleUnhandled.bind(null, 'unhandled rejection'))
 
-export default async function (opts) {
+export default async function () {
   try {
     /* c8 ignore next */
     const protocol = platform() === 'win32' ? 'ws+unix:' : 'ws+unix://'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/basic",
-  "version": "2.6.1",
+  "version": "2.8.0-alpha.1",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -23,11 +23,11 @@
     "split2": "^4.2.0",
     "undici": "^6.19.5",
     "ws": "^8.18.0",
-    "@platformatic/config": "2.6.1",
-    "@platformatic/itc": "2.6.1",
-    "@platformatic/telemetry": "2.6.1",
-    "@platformatic/metrics": "2.6.1",
-    "@platformatic/utils": "2.6.1"
+    "@platformatic/config": "2.8.0-alpha.1",
+    "@platformatic/itc": "2.8.0-alpha.1",
+    "@platformatic/metrics": "2.8.0-alpha.1",
+    "@platformatic/telemetry": "2.8.0-alpha.1",
+    "@platformatic/utils": "2.8.0-alpha.1"
   },
   "devDependencies": {
     "borp": "^0.18.0",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/basic/2.6.1.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/basic/2.8.0-alpha.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Stackable",
   "type": "object",