@platformatic/runtime 3.4.1 → 3.5.0

package/lib/worker/itc.js

@@ -1,13 +1,22 @@
-'use strict'
-
-const { once } = require('node:events')
-const { parentPort } = require('node:worker_threads')
-
-const { ITC } = require('@platformatic/itc')
-const { Unpromise } = require('@watchable/unpromise')
-
-const errors = require('../errors')
-const { kITC, kId } = require('./symbols')
+import { ensureLoggableError } from '@platformatic/foundation'
+import { ITC } from '@platformatic/itc'
+import { Unpromise } from '@watchable/unpromise'
+import { once } from 'node:events'
+import { parentPort, workerData } from 'node:worker_threads'
+import {
+  ApplicationExitedError,
+  FailedToPerformCustomHealthCheckError,
+  FailedToPerformCustomReadinessCheckError,
+  FailedToRetrieveGraphQLSchemaError,
+  FailedToRetrieveHealthError,
+  FailedToRetrieveMetaError,
+  FailedToRetrieveMetricsError,
+  FailedToRetrieveOpenAPISchemaError,
+  WorkerExitedError
+} from '../errors.js'
+import { updateUndiciInterceptors } from './interceptors.js'
+import { MessagingITC } from './messaging.js'
+import { kApplicationId, kITC, kId, kWorkerId } from './symbols.js'
 
 async function safeHandleInITC (worker, fn) {
   try {
@@ -23,7 +32,11 @@ async function safeHandleInITC (worker, fn) {
     ])
 
     if (typeof exitCode === 'number') {
-      throw new errors.ServiceExitedError(worker[kId], exitCode)
+      if (typeof worker[kWorkerId] !== 'undefined') {
+        throw new WorkerExitedError(worker[kWorkerId], worker[kApplicationId], exitCode)
+      } else {
+        throw new ApplicationExitedError(worker[kId], exitCode)
+      }
     } else {
       ac.abort()
     }
@@ -42,121 +55,195 @@ async function safeHandleInITC (worker, fn) {
   }
 }
 
-async function sendViaITC (worker, name, message) {
-  return safeHandleInITC(worker, () => worker[kITC].send(name, message))
+async function closeITC (dispatcher, itc, messaging) {
+  await dispatcher.interceptor.close()
+  itc.close()
+  messaging.close()
+}
+
+export async function sendViaITC (worker, name, message, transferList) {
+  return safeHandleInITC(worker, () => worker[kITC].send(name, message, { transferList }))
 }
 
-async function waitEventFromITC (worker, event) {
+export async function waitEventFromITC (worker, event) {
   return safeHandleInITC(worker, () => once(worker[kITC], event))
 }
 
-function setupITC (app, service, dispatcher) {
+export function setupITC (controller, application, dispatcher, sharedContext) {
+  const messaging = new MessagingITC(controller.appConfig.id, workerData.config)
+
+  Object.assign(globalThis.platformatic ?? {}, {
+    messaging: {
+      handle: messaging.handle.bind(messaging),
+      send: messaging.send.bind(messaging)
+    }
+  })
+
   const itc = new ITC({
-    name: app.appConfig.id + '-worker',
+    name: controller.appConfig.id + '-worker',
     port: parentPort,
     handlers: {
       async start () {
-        const status = app.getStatus()
+        const status = controller.getStatus()
 
         if (status === 'starting') {
-          await once(app, 'start')
+          await once(controller, 'start')
         } else {
-          await app.start()
-        }
+          // This gives a chance to a capability to perform custom logic
+          globalThis.platformatic.events.emit('start')
 
-        if (service.entrypoint) {
-          await app.listen()
-        }
+          try {
+            await controller.start()
+          } catch (e) {
+            await controller.stop(true)
 
-        const url = app.stackable.getUrl()
+            // Reply to the runtime that the start failed, so it can cleanup
+            once(itc, 'application:worker:start:processed').then(() => {
+              closeITC(dispatcher, itc, messaging).catch(() => {})
+            })
 
-        const dispatchFunc = await app.stackable.getDispatchFunc()
-        dispatcher.replaceServer(url ?? dispatchFunc)
+            throw ensureLoggableError(e)
+          }
+        }
+
+        if (application.entrypoint) {
+          await controller.listen()
+        }
 
-        return service.entrypoint ? url : null
+        dispatcher.replaceServer(await controller.capability.getDispatchTarget())
+        return application.entrypoint ? controller.capability.getUrl() : null
       },
 
-      async stop () {
-        const status = app.getStatus()
+      async stop ({ force, dependents }) {
+        const status = controller.getStatus()
 
-        if (status === 'starting') {
-          await once(app, 'start')
+        if (!force && status === 'starting') {
+          await once(controller, 'start')
         }
 
-        if (status !== 'stopped') {
-          await app.stop()
+        if (force || status.startsWith('start')) {
+          // This gives a chance to a capability to perform custom logic
+          globalThis.platformatic.events.emit('stop')
+
+          await controller.stop(force, dependents)
         }
 
-        dispatcher.interceptor.close()
-        itc.close()
+        once(itc, 'application:worker:stop:processed').then(() => {
+          closeITC(dispatcher, itc, messaging).catch(() => {})
+        })
       },
 
       async build () {
-        return app.stackable.build()
+        return controller.capability.build()
+      },
+
+      async removeFromMesh () {
+        return dispatcher.interceptor.close()
+      },
+
+      inject (injectParams) {
+        return controller.capability.inject(injectParams)
+      },
+
+      async updateUndiciInterceptors (undiciConfig) {
+        await updateUndiciInterceptors(undiciConfig)
+      },
+
+      async updateWorkersCount (data) {
+        const { workers } = data
+        workerData.applicationConfig.workers = workers
+        workerData.worker.count = workers
       },
 
       getStatus () {
-        return app.getStatus()
+        return controller.getStatus()
       },
 
-      getServiceInfo () {
-        return app.stackable.getInfo()
+      getApplicationInfo () {
+        return controller.capability.getInfo()
       },
 
-      async getServiceConfig () {
-        const current = await app.stackable.getConfig()
+      async getApplicationConfig () {
+        const current = await controller.capability.getConfig()
         // Remove all undefined keys from the config
         return JSON.parse(JSON.stringify(current))
       },
 
-      async getServiceEnv () {
+      async getApplicationEnv () {
         // Remove all undefined keys from the config
-        return JSON.parse(JSON.stringify({ ...process.env, ...(await app.stackable.getEnv()) }))
+        return JSON.parse(JSON.stringify({ ...process.env, ...(await controller.capability.getEnv()) }))
       },
 
-      async getServiceOpenAPISchema () {
+      async getApplicationOpenAPISchema () {
         try {
-          return await app.stackable.getOpenapiSchema()
+          return await controller.capability.getOpenapiSchema()
         } catch (err) {
-          throw new errors.FailedToRetrieveOpenAPISchemaError(service.id, err.message)
+          throw new FailedToRetrieveOpenAPISchemaError(application.id, err.message)
         }
       },
 
-      async getServiceGraphQLSchema () {
+      async getApplicationGraphQLSchema () {
         try {
-          return await app.stackable.getGraphqlSchema()
+          return await controller.capability.getGraphqlSchema()
         } catch (err) {
-          throw new errors.FailedToRetrieveGraphQLSchemaError(service.id, err.message)
+          throw new FailedToRetrieveGraphQLSchemaError(application.id, err.message)
         }
       },
 
-      async getServiceMeta () {
+      async getApplicationMeta () {
         try {
-          return await app.stackable.getMeta()
+          return await controller.capability.getMeta()
         } catch (err) {
-          throw new errors.FailedToRetrieveMetaError(service.id, err.message)
+          throw new FailedToRetrieveMetaError(application.id, err.message)
         }
       },
 
       async getMetrics (format) {
         try {
-          return await app.getMetrics({ format })
+          return await controller.getMetrics({ format })
         } catch (err) {
-          throw new errors.FailedToRetrieveMetricsError(service.id, err.message)
+          throw new FailedToRetrieveMetricsError(application.id, err.message)
         }
       },
 
-      inject (injectParams) {
-        return app.stackable.inject(injectParams)
+      async getHealth () {
+        try {
+          return await controller.getHealth()
+        } catch (err) {
+          throw new FailedToRetrieveHealthError(application.id, err.message)
+        }
+      },
+
+      async getCustomHealthCheck () {
+        try {
+          return await controller.capability.getCustomHealthCheck()
+        } catch (err) {
+          throw new FailedToPerformCustomHealthCheckError(application.id, err.message)
+        }
+      },
+
+      async getCustomReadinessCheck () {
+        try {
+          return await controller.capability.getCustomReadinessCheck()
+        } catch (err) {
+          throw new FailedToPerformCustomReadinessCheckError(application.id, err.message)
+        }
+      },
+
+      setSharedContext (context) {
+        sharedContext._set(context)
+      },
+
+      saveMessagingChannel (channel) {
+        messaging.addSource(channel)
       }
     }
   })
 
-  app.on('changed', () => {
+  controller.on('changed', () => {
     itc.notify('changed')
   })
 
+  itc.listen()
   return itc
 }
-
-module.exports = { sendViaITC, setupITC, waitEventFromITC }

package/lib/worker/main.js

@@ -1,40 +1,35 @@
-'use strict'
-
-const { createRequire } = require('node:module')
-const { join } = require('node:path')
-const { parentPort, workerData, threadId } = require('node:worker_threads')
-const { pathToFileURL } = require('node:url')
-
-const pino = require('pino')
-const { fetch, setGlobalDispatcher, Agent } = require('undici')
-const { wire } = require('undici-thread-interceptor')
-
-const { PlatformaticApp } = require('./app')
-const { setupITC } = require('./itc')
-const loadInterceptors = require('./interceptors')
-const {
-  MessagePortWritable,
-  createPinoWritable,
+import {
+  buildPinoFormatters,
+  buildPinoTimestamp,
+  disablePinoDirectWrite,
+  ensureLoggableError,
   executeWithTimeout,
-  ensureLoggableError
-} = require('@platformatic/utils')
-const { kId, kITC } = require('./symbols')
+  getPrivateSymbol
+} from '@platformatic/foundation'
+import dotenv from 'dotenv'
+import { subscribe } from 'node:diagnostics_channel'
+import { EventEmitter } from 'node:events'
+import { ServerResponse } from 'node:http'
+import inspector from 'node:inspector'
+import { hostname } from 'node:os'
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { threadId, workerData } from 'node:worker_threads'
+import pino from 'pino'
+import { fetch } from 'undici'
+import { Controller } from './controller.js'
+import { setDispatcher } from './interceptors.js'
+import { setupITC } from './itc.js'
+import { SharedContext } from './shared-context.js'
+import { kId, kITC, kStderrMarker } from './symbols.js'
 
-process.on('uncaughtException', handleUnhandled.bind(null, 'uncaught exception'))
-process.on('unhandledRejection', handleUnhandled.bind(null, 'unhandled rejection'))
+function handleUnhandled (app, type, err) {
+  const label =
+    workerData.worker.count > 1
+      ? `worker ${workerData.worker.index} of the application "${workerData.applicationConfig.id}"`
+      : `application "${workerData.applicationConfig.id}"`
 
-globalThis.fetch = fetch
-globalThis[kId] = threadId
-
-let app
-const config = workerData.config
-globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, { logger: createLogger() })
-
-function handleUnhandled (type, err) {
-  globalThis.platformatic.logger.error(
-    { err: ensureLoggableError(err) },
-    `Service ${workerData.serviceConfig.id} threw an ${type}.`
-  )
+  globalThis.platformatic.logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${type}.`)
 
   executeWithTimeout(app?.stop(), 1000)
     .catch()
@@ -43,55 +38,108 @@ function handleUnhandled (type, err) {
     })
 }
 
-function createLogger () {
-  const destination = new MessagePortWritable({ port: workerData.loggingPort })
-  const loggerInstance = pino({ level: 'trace', name: workerData.serviceConfig.id }, destination)
+function patchLogging () {
+  disablePinoDirectWrite()
+
+  const kFormatForStderr = getPrivateSymbol(console, 'kFormatForStderr')
 
-  Reflect.defineProperty(process, 'stdout', { value: createPinoWritable(loggerInstance, 'info') })
-  Reflect.defineProperty(process, 'stderr', { value: createPinoWritable(loggerInstance, 'error') })
+  // To avoid out of order printing on the main thread, instruct console to only print to the stdout.
+  console._stderr = console._stdout
+  console._stderrErrorHandler = console._stdoutErrorHandler
 
-  return loggerInstance
+  // To recognize stderr in the main thread, each line is prepended with a special private Unicode character.
+  const originalFormatter = console[kFormatForStderr]
+  console[kFormatForStderr] = function (args) {
+    let string = kStderrMarker + originalFormatter(args).replaceAll('\n', '\n' + kStderrMarker)
+
+    if (string.endsWith(kStderrMarker)) {
+      string = string.slice(0, -1)
+    }
+
+    return string
+  }
 }
 
-async function main () {
-  if (config.preload) {
-    await import(pathToFileURL(config.preload))
+function createLogger () {
+  // Do not propagate runtime transports to the worker
+  if (workerData.config.logger) {
+    delete workerData.config.logger.transport
+  }
+
+  const pinoOptions = {
+    level: 'trace',
+    name: workerData.applicationConfig.id,
+    ...workerData.config.logger
+  }
+
+  if (workerData.worker?.count > 1) {
+    pinoOptions.base = { pid: process.pid, hostname: hostname(), worker: workerData.worker.index }
+  }
+
+  if (pinoOptions.formatters) {
+    pinoOptions.formatters = buildPinoFormatters(pinoOptions.formatters)
+  }
+  if (pinoOptions.timestamp) {
+    pinoOptions.timestamp = buildPinoTimestamp(pinoOptions.timestamp)
   }
 
-  const service = workerData.serviceConfig
+  return pino(pinoOptions)
+}
 
-  // Setup undici
-  const interceptors = {}
-  const composedInterceptors = []
+async function performPreloading (...sources) {
+  for (const source of sources) {
+    const preload = typeof source.preload === 'string' ? [source.preload] : source.preload
 
-  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(preload)) {
+      for (const file of preload) {
+        await import(pathToFileURL(file))
       }
     }
+  }
+}
 
-    if (Array.isArray(config.undici.interceptors)) {
-      composedInterceptors.push(...(await loadInterceptors(_require, config.undici.interceptors)))
-    }
+async function main () {
+  globalThis.fetch = fetch
+  globalThis[kId] = threadId
+  globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, {
+    logger: createLogger(),
+    events: new EventEmitter()
+  })
+
+  const config = workerData.config
+
+  await performPreloading(config, workerData.applicationConfig)
+
+  const application = workerData.applicationConfig
+
+  // Load env file and mixin env vars from application config
+  let envfile
+  if (application.envfile) {
+    envfile = resolve(workerData.dirname, application.envfile)
+  } else {
+    envfile = resolve(workerData.applicationConfig.path, '.env')
   }
 
-  const globalDispatcher = new Agent({
-    ...config.undici,
-    interceptors
-  }).compose(composedInterceptors)
+  globalThis.platformatic.logger.debug({ envfile }, 'Loading envfile...')
+
+  dotenv.config({
+    path: envfile
+  })
 
-  setGlobalDispatcher(globalDispatcher)
+  if (config.env) {
+    Object.assign(process.env, config.env)
+  }
+  if (application.env) {
+    Object.assign(process.env, application.env)
+  }
 
-  // Setup mesh networker
-  const threadDispatcher = wire({ port: parentPort, useNetwork: service.useHttp, timeout: true })
+  const { threadDispatcher } = await setDispatcher(config)
 
-  // If the service is an entrypoint and runtime server config is defined, use it.
+  // If the application is an entrypoint and runtime server config is defined, use it.
   let serverConfig = null
-  if (config.server && service.entrypoint) {
+  if (config.server && application.entrypoint) {
     serverConfig = config.server
-  } else if (service.useHttp) {
+  } else if (application.useHttp) {
     serverConfig = {
       port: 0,
       hostname: '127.0.0.1',
@@ -99,37 +147,128 @@ async function main () {
     }
   }
 
-  let telemetryConfig = config.telemetry
-  if (telemetryConfig) {
-    telemetryConfig = {
-      ...telemetryConfig,
-      serviceName: `${telemetryConfig.serviceName}-${service.id}`
+  const inspectorOptions = workerData.inspectorOptions
+
+  if (inspectorOptions) {
+    for (let i = 0; !inspector.url(); i++) {
+      inspector.open(inspectorOptions.port + i, inspectorOptions.host, inspectorOptions.breakFirstLine)
     }
+
+    const url = new URL(inspector.url())
+
+    url.protocol = 'http'
+    url.pathname = '/json/list'
+
+    const res = await fetch(url)
+    const [{ devtoolsFrontendUrl }] = await res.json()
+
+    console.log(`For ${application.id} debugger open the following in chrome: "${devtoolsFrontendUrl}"`)
   }
 
   // Create the application
-  app = new PlatformaticApp(
-    service,
-    telemetryConfig,
+  // Add idLabel to metrics config to determine which label name to use (defaults to applicationId)
+  const metricsConfig = config.metrics
+    ? {
+        ...config.metrics,
+        idLabel: config.metrics.applicationLabel || 'applicationId'
+      }
+    : config.metrics
+
+  const controller = new Controller(
+    application,
+    workerData.worker.count > 1 ? workerData.worker.index : undefined,
+    application.telemetry,
     config.logger,
     serverConfig,
-    config.metrics,
+    metricsConfig,
     !!config.managementApi,
     !!config.watch
   )
 
-  await app.init()
+  if (config.exitOnUnhandledErrors) {
+    process.on('uncaughtException', handleUnhandled.bind(null, controller, 'uncaught exception'))
+    process.on('unhandledRejection', handleUnhandled.bind(null, controller, 'unhandled rejection'))
 
-  // Setup interaction with parent port
-  const itc = setupITC(app, service, threadDispatcher)
+    process.on('newListener', event => {
+      if (event === 'uncaughtException' || event === 'unhandledRejection') {
+        globalThis.platformatic.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.`
+        )
+      }
+    })
+  }
 
-  // Get the dependencies
-  const dependencies = config.autoload ? await app.getBootstrapDependencies() : []
-  itc.notify('init', { dependencies })
-  itc.listen()
+  await controller.init()
 
+  if (application.entrypoint && config.basePath) {
+    const meta = await controller.capability.getMeta()
+    if (!meta.gateway.wantsAbsoluteUrls) {
+      stripBasePath(config.basePath)
+    }
+  }
+
+  const sharedContext = new SharedContext()
+  // Limit the amount of methods a user can call
+  globalThis.platformatic.sharedContext = {
+    get: () => sharedContext.get(),
+    update: (...args) => sharedContext.update(...args)
+  }
+
+  // Setup interaction with parent port
+  const itc = setupITC(controller, application, threadDispatcher, sharedContext)
   globalThis[kITC] = itc
+
+  itc.notify('init')
+}
+
+function stripBasePath (basePath) {
+  const kBasePath = Symbol('kBasePath')
+
+  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)
+  }
 }
 
+patchLogging()
+
 // No need to catch this because there is the unhadledRejection handler on top.
 main()