@platformatic/basic 3.4.1 → 3.5.0

package/lib/worker/child-process.js

@@ -1,24 +1,44 @@
-import { ITC } from '@platformatic/itc'
-import { setupNodeHTTPTelemetry } from '@platformatic/telemetry'
-import { createPinoWritable, ensureLoggableError } from '@platformatic/utils'
-import { tracingChannel } from 'node:diagnostics_channel'
-import { once } from 'node:events'
+import {
+  buildPinoFormatters,
+  buildPinoTimestamp,
+  disablePinoDirectWrite,
+  ensureLoggableError,
+  features
+} from '@platformatic/foundation'
+import { ITC } from '@platformatic/itc/lib/index.js'
+import { client, collectMetrics } from '@platformatic/metrics'
+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'
 import pino from 'pino'
-import { getGlobalDispatcher, setGlobalDispatcher } from 'undici'
+import { Agent, Pool, 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 () {
+  const pool = new Pool(
+    {
+      hostname: 'localhost',
+      protocol: 'http:'
+    },
+    {
+      socketPath: getSocketPath(process.env.PLT_MANAGER_ID),
+      keepAliveTimeout: 10,
+      keepAliveMaxTimeout: 10
+    }
+  )
 
-function createInterceptor (itc) {
   return function (dispatch) {
-    return async (opts, handler) => {
+    return (opts, handler) => {
       let url = opts.origin
       if (!(url instanceof URL)) {
         url = new URL(opts.path, url)
@@ -29,49 +49,17 @@ function createInterceptor (itc) {
         return dispatch(opts, handler)
       }
 
-      const headers = {
-        ...opts?.headers
-      }
-
-      delete headers.connection
-      delete headers['transfer-encoding']
-      headers.host = url.host
-
-      const requestOpts = {
-        ...opts,
-        headers
-      }
-      delete requestOpts.dispatcher
-
-      itc
-        .send('fetch', requestOpts)
-        .then(res => {
-          if (res.rawPayload && !Buffer.isBuffer(res.rawPayload)) {
-            res.rawPayload = Buffer.from(res.rawPayload.data)
-          }
-
-          const headers = []
-          for (const [key, value] of Object.entries(res.headers)) {
-            if (Array.isArray(value)) {
-              for (const v of value) {
-                headers.push(key)
-                headers.push(v)
-              }
-            } else {
-              headers.push(key)
-              headers.push(value)
-            }
+      // Route the call via the UNIX socket
+      return pool.dispatch(
+        {
+          ...opts,
+          headers: {
+            host: url.host,
+            ...opts?.headers
           }
-
-          handler.onHeaders(res.statusCode, headers, () => {}, res.statusMessage)
-          handler.onData(res.rawPayload)
-          handler.onComplete([])
-        })
-        .catch(e => {
-          handler.onError(new Error(e.message))
-        })
-
-      return true
+        },
+        handler
+      )
     }
   }
 }
@@ -79,30 +67,90 @@ function createInterceptor (itc) {
 export class ChildProcess extends ITC {
   #listener
   #socket
-  #child
   #logger
+  #metricsRegistry
   #pendingMessages
 
   constructor () {
-    super({ throwOnMissingHandler: false, name: `${process.env.PLT_MANAGER_ID}-child-process` })
+    super({
+      throwOnMissingHandler: false,
+      name: `${process.env.PLT_MANAGER_ID}-child-process`,
+      handlers: {
+        collectMetrics: (...args) => {
+          return this.#collectMetrics(...args)
+        },
+        getMetrics: (...args) => {
+          return this.#getMetrics(...args)
+        },
+        close: signal => {
+          let handled = false
+
+          try {
+            handled = globalThis.platformatic.events.emit('close', signal)
+          } catch (error) {
+            this.#logger.error({ err: ensureLoggableError(error) }, 'Error while handling close event.')
+            process.exitCode = 1
+          }
+
+          if (!handled) {
+            // No user event, just exit without errors
+            setImmediate(() => {
+              process.exit(process.exitCode ?? 0)
+            })
+          }
+
+          return handled
+        }
+      }
+    })
 
     /* c8 ignore next */
     const protocol = platform() === 'win32' ? 'ws+unix:' : 'ws+unix://'
     this.#socket = new WebSocket(`${protocol}${getSocketPath(process.env.PLT_MANAGER_ID)}`)
     this.#pendingMessages = []
+    this.#metricsRegistry = new client.Registry()
 
     this.listen()
     this.#setupLogger()
-    this.#setupTelemetry()
-    this.#setupHandlers()
+
+    if (globalThis.platformatic.exitOnUnhandledErrors) {
+      this.#setupHandlers()
+    }
+
     this.#setupServer()
     this.#setupInterceptors()
 
-    this.on('close', signal => {
-      process.kill(process.pid, signal)
+    this.registerGlobals({
+      logger: this.#logger,
+      setOpenapiSchema: this.setOpenapiSchema.bind(this),
+      setGraphqlSchema: this.setGraphqlSchema.bind(this),
+      setConnectionString: this.setConnectionString.bind(this),
+      setBasePath: this.setBasePath.bind(this),
+      prometheus: { client, registry: this.#metricsRegistry },
+      notifyConfig: this.#notifyConfig.bind(this)
     })
   }
 
+  registerGlobals (globals) {
+    globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, globals)
+  }
+
+  setOpenapiSchema (schema) {
+    this.notify('openapiSchema', schema)
+  }
+
+  setGraphqlSchema (schema) {
+    this.notify('graphqlSchema', schema)
+  }
+
+  setConnectionString (connectionString) {
+    this.notify('connectionString', connectionString)
+  }
+
+  setBasePath (basePath) {
+    this.notify('basePath', basePath)
+  }
+
   _setupListener (listener) {
     this.#listener = listener
 
@@ -152,31 +200,138 @@ export class ChildProcess extends ITC {
     this.#socket.close()
   }
 
-  #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.
-    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 }
-        }
-      })
+  async #collectMetrics ({ applicationId, workerId, metricsConfig }) {
+    await collectMetrics(applicationId, workerId, metricsConfig, this.#metricsRegistry)
+    this.#setHttpCacheMetrics()
+  }
+
+  #setHttpCacheMetrics () {
+    const { client, registry } = globalThis.platformatic.prometheus
+
+    const cacheHitMetric = new client.Counter({
+      name: 'http_cache_hit_count',
+      help: 'Number of http cache hits',
+      registers: [registry]
+    })
+
+    const cacheMissMetric = new client.Counter({
+      name: 'http_cache_miss_count',
+      help: 'Number of http cache misses',
+      registers: [registry]
+    })
+
+    globalThis.platformatic.onHttpCacheHit = () => {
+      cacheHitMetric.inc()
+    }
+    globalThis.platformatic.onHttpCacheMiss = () => {
+      cacheMissMetric.inc()
+    }
+
+    const httpStatsFreeMetric = new client.Gauge({
+      name: 'http_client_stats_free',
+      help: 'Number of free (idle) http clients (sockets)',
+      labelNames: ['dispatcher_stats_url'],
+      registers: [registry]
+    })
+    globalThis.platformatic.onHttpStatsFree = (url, val) => {
+      httpStatsFreeMetric.set({ dispatcher_stats_url: url }, val)
+    }
+
+    const httpStatsConnectedMetric = new client.Gauge({
+      name: 'http_client_stats_connected',
+      help: 'Number of open socket connections',
+      labelNames: ['dispatcher_stats_url'],
+      registers: [registry]
+    })
+    globalThis.platformatic.onHttpStatsConnected = (url, val) => {
+      httpStatsConnectedMetric.set({ dispatcher_stats_url: url }, val)
+    }
 
-      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 })
+    const httpStatsPendingMetric = new client.Gauge({
+      name: 'http_client_stats_pending',
+      help: 'Number of pending requests across all clients',
+      labelNames: ['dispatcher_stats_url'],
+      registers: [registry]
+    })
+    globalThis.platformatic.onHttpStatsPending = (url, val) => {
+      httpStatsPendingMetric.set({ dispatcher_stats_url: url }, val)
+    }
+
+    const httpStatsQueuedMetric = new client.Gauge({
+      name: 'http_client_stats_queued',
+      help: 'Number of queued requests across all clients',
+      labelNames: ['dispatcher_stats_url'],
+      registers: [registry]
+    })
+    globalThis.platformatic.onHttpStatsQueued = (url, val) => {
+      httpStatsQueuedMetric.set({ dispatcher_stats_url: url }, val)
+    }
+
+    const httpStatsRunningMetric = new client.Gauge({
+      name: 'http_client_stats_running',
+      help: 'Number of currently active requests across all clients',
+      labelNames: ['dispatcher_stats_url'],
+      registers: [registry]
+    })
+    globalThis.platformatic.onHttpStatsRunning = (url, val) => {
+      httpStatsRunningMetric.set({ dispatcher_stats_url: url }, val)
     }
+
+    const httpStatsSizeMetric = new client.Gauge({
+      name: 'http_client_stats_size',
+      help: 'Number of active, pending, or queued requests across all clients',
+      labelNames: ['dispatcher_stats_url'],
+      registers: [registry]
+    })
+    globalThis.platformatic.onHttpStatsSize = (url, val) => {
+      httpStatsSizeMetric.set({ dispatcher_stats_url: url }, val)
+    }
+
+    const activeResourcesEventLoopMetric = new client.Gauge({
+      name: 'active_resources_event_loop',
+      help: 'Number of active resources keeping the event loop alive',
+      registers: [registry]
+    })
+    globalThis.platformatic.onActiveResourcesEventLoop = val => activeResourcesEventLoopMetric.set(val)
+  }
+
+  async #getMetrics ({ format } = {}) {
+    const res =
+      format === 'json' ? await this.#metricsRegistry.getMetricsAsJSON() : await this.#metricsRegistry.metrics()
+
+    return res
   }
 
-  /* c8 ignore next 5 */
-  #setupTelemetry () {
-    if (globalThis.platformatic.telemetry) {
-      setupNodeHTTPTelemetry(globalThis.platformatic.telemetry, this.#logger)
+  #setupLogger () {
+    disablePinoDirectWrite()
+
+    // Since this is executed by user code, make sure we only override this in the main thread
+    // The rest will be intercepted by the BaseCapability.
+    const loggerOptions = globalThis.platformatic?.config?.logger ?? {}
+    const pinoOptions = {
+      ...loggerOptions,
+      level: loggerOptions.level ?? 'info',
+      name: globalThis.platformatic.applicationId
+    }
+    if (loggerOptions.formatters) {
+      pinoOptions.formatters = buildPinoFormatters(loggerOptions.formatters)
+    }
+    if (loggerOptions.timestamp) {
+      pinoOptions.timestamp = buildPinoTimestamp(loggerOptions.timestamp)
+    }
+
+    if (loggerOptions.base !== null && typeof globalThis.platformatic.workerId !== 'undefined') {
+      pinoOptions.base = {
+        ...(pinoOptions.base ?? {}),
+        pid: process.pid,
+        hostname: hostname(),
+        worker: parseInt(globalThis.platformatic.workerId)
+      }
+    } else if (loggerOptions.base === null) {
+      pinoOptions.base = undefined
     }
+
+    this.#logger = pino(pinoOptions)
   }
 
   #setupServer () {
@@ -191,8 +346,14 @@ export class ChildProcess extends ITC {
         const host = globalThis.platformatic.host
 
         if (port !== false) {
-          options.port = typeof port === 'number' ? port : 0
+          const hasFixedPort = typeof port === 'number'
+          options.port = hasFixedPort ? port : 0
+
+          if (hasFixedPort && features.node.reusePort) {
+            options.reusePort = true
+          }
         }
+
         if (typeof host === 'string') {
           options.host = host
         }
@@ -220,18 +381,26 @@ export class ChildProcess extends ITC {
     }
 
     tracingChannel('net.server.listen').subscribe(subscribers)
+
+    const { isEntrypoint, runtimeBasePath, wantsAbsoluteUrls } = globalThis.platformatic
+    if (isEntrypoint && runtimeBasePath && !wantsAbsoluteUrls) {
+      stripBasePath(runtimeBasePath)
+    }
   }
 
   #setupInterceptors () {
-    setGlobalDispatcher(getGlobalDispatcher().compose(createInterceptor(this)))
+    const globalDispatcher = new Agent().compose(createInterceptor(this))
+    setGlobalDispatcher(globalDispatcher)
   }
 
   #setupHandlers () {
+    const errorLabel =
+      typeof globalThis.platformatic.workerId !== 'undefined'
+        ? `worker ${globalThis.platformatic.workerId} of the application "${globalThis.platformatic.applicationId}"`
+        : `application "${globalThis.platformatic.applicationId}"`
+
     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)
@@ -239,18 +408,79 @@ export class ChildProcess extends ITC {
 
     process.on('uncaughtException', handleUnhandled.bind(this, 'uncaught exception'))
     process.on('unhandledRejection', handleUnhandled.bind(this, 'unhandled rejection'))
+
+    process.on('newListener', event => {
+      if (event === 'uncaughtException' || event === 'unhandledRejection') {
+        this.#logger.warn(
+          `A listener has been added for the "process.${event}" event. This listener will be never triggered as Watt default behavior will kill the process before.\n To disable this behavior, set "exitOnUnhandledErrors" to false in the runtime config.`
+        )
+      }
+    })
+  }
+
+  #notifyConfig (config) {
+    this.notify('config', config)
+  }
+}
+
+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
-
-  if (data.root && isMainThread) {
-    process.chdir(fileURLToPath(data.root))
-  }
+  globalThis.platformatic.events = new EventEmitter()
 
   if (loader) {
     register(loader, { data })
@@ -263,7 +493,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/listeners.js

@@ -1,8 +1,8 @@
-import { withResolvers } from '@platformatic/utils'
+import { features } from '@platformatic/foundation'
 import { subscribe, tracingChannel, unsubscribe } from 'node:diagnostics_channel'
 
 export function createServerListener (overridePort = true, overrideHost) {
-  const { promise, resolve, reject } = withResolvers()
+  const { promise, resolve, reject } = Promise.withResolvers()
 
   const subscribers = {
     asyncStart ({ options }) {
@@ -12,8 +12,14 @@ export function createServerListener (overridePort = true, overrideHost) {
       }
 
       if (overridePort !== false) {
-        options.port = typeof overridePort === 'number' ? overridePort : 0
+        const hasFixedPort = typeof overridePort === 'number'
+        options.port = hasFixedPort ? overridePort : 0
+
+        if (hasFixedPort && features.node.reusePort) {
+          options.reusePort = true
+        }
       }
+
       if (typeof overrideHost === 'string') {
         options.host = overrideHost
       }
@@ -42,7 +48,7 @@ export function createServerListener (overridePort = true, overrideHost) {
 }
 
 export function createChildProcessListener () {
-  const { promise, resolve } = withResolvers()
+  const { promise, resolve } = Promise.withResolvers()
 
   const handler = ({ process: child }) => {
     unsubscribe('child_process', handler)

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@platformatic/basic",
-  "version": "3.4.1",
+  "version": "3.5.0",
   "description": "",
   "main": "index.js",
+  "types": "index.d.ts",
   "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/platformatic/platformatic.git"
   },
-  "author": "Paolo Insogna <paolo@cowtech.it>",
+  "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/platformatic/platformatic/issues"
@@ -17,36 +18,36 @@
   "dependencies": {
     "@fastify/error": "^4.0.0",
     "execa": "^9.3.1",
-    "pino": "^9.3.2",
+    "fast-json-patch": "^3.1.1",
+    "pino": "^9.9.0",
     "pino-abstract-transport": "^2.0.0",
     "semver": "^7.6.3",
     "split2": "^4.2.0",
-    "undici": "^6.19.5",
+    "undici": "^7.0.0",
     "ws": "^8.18.0",
-    "@platformatic/config": "3.4.1",
-    "@platformatic/itc": "3.4.1",
-    "@platformatic/telemetry": "3.4.1",
-    "@platformatic/utils": "3.4.1"
+    "@platformatic/foundation": "3.5.0",
+    "@platformatic/itc": "3.5.0",
+    "@platformatic/metrics": "3.5.0",
+    "@platformatic/telemetry": "3.5.0"
   },
   "devDependencies": {
-    "borp": "^0.17.0",
+    "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
     "express": "^4.19.2",
     "fastify": "^5.0.0",
+    "get-port": "^7.1.0",
     "json-schema-to-typescript": "^15.0.0",
-    "neostandard": "^0.11.1",
-    "next": "^14.2.5",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "typescript": "^5.5.4",
-    "vite": "^5.4.0"
+    "neostandard": "^0.12.0",
+    "typescript": "^5.5.4"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   },
   "scripts": {
-    "test": "npm run lint && borp --concurrency=1 --no-timeout",
-    "coverage": "npm run lint && borp -C -X test -X test/fixtures --concurrency=1 --no-timeout",
+    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
     "gen-schema": "node lib/schema.js > schema.json",
     "gen-types": "json2ts > config.d.ts < schema.json",
-    "build": "pnpm run gen-schema && pnpm run gen-types",
+    "build": "npm run gen-schema && npm run gen-types",
     "lint": "eslint"
   }
 }