@platformatic/runtime 2.0.0-alpha.2 → 2.0.0-alpha.20

package/lib/worker/app.js

@@ -0,0 +1,266 @@
+'use strict'
+
+const { EventEmitter } = require('node:events')
+const { FileWatcher } = require('@platformatic/utils')
+const { getGlobalDispatcher, setGlobalDispatcher } = require('undici')
+const debounce = require('debounce')
+
+const errors = require('../errors')
+const defaultStackable = require('./default-stackable')
+const { collectMetrics } = require('./metrics')
+const { getServiceUrl, loadConfig, loadEmptyConfig } = require('../utils')
+
+class PlatformaticApp extends EventEmitter {
+  #starting
+  #started
+  #listening
+  #watch
+  #fileWatcher
+  #metricsRegistry
+  #debouncedRestart
+  #context
+
+  constructor (appConfig, telemetryConfig, loggerConfig, serverConfig, metricsConfig, hasManagementApi, watch) {
+    super()
+    this.appConfig = appConfig
+    this.#watch = watch
+    this.#starting = false
+    this.#started = false
+    this.#listening = false
+    this.stackable = null
+    this.#fileWatcher = null
+    this.#metricsRegistry = null
+
+    this.#context = {
+      serviceId: this.appConfig.id,
+      directory: this.appConfig.path,
+      isEntrypoint: this.appConfig.entrypoint,
+      isProduction: this.appConfig.isProduction,
+      telemetryConfig,
+      metricsConfig,
+      loggerConfig,
+      serverConfig,
+      hasManagementApi: !!hasManagementApi,
+      localServiceEnvVars: this.appConfig.localServiceEnvVars
+    }
+  }
+
+  getStatus () {
+    if (this.#starting) return 'starting'
+    if (this.#started) return 'started'
+    return 'stopped'
+  }
+
+  async updateContext (context) {
+    this.#context = { ...this.#context, ...context }
+    if (this.stackable) {
+      this.stackable.updateContext(context)
+    }
+  }
+
+  async getBootstrapDependencies () {
+    return this.stackable.getBootstrapDependencies()
+  }
+
+  async init () {
+    try {
+      const appConfig = this.appConfig
+      let loadedConfig
+
+      if (!appConfig.config) {
+        loadedConfig = await loadEmptyConfig(
+          appConfig.path,
+          {
+            onMissingEnv: this.#fetchServiceUrl,
+            context: appConfig
+          },
+          true
+        )
+      } else {
+        loadedConfig = await loadConfig(
+          {},
+          ['-c', appConfig.config],
+          {
+            onMissingEnv: this.#fetchServiceUrl,
+            context: appConfig
+          },
+          true
+        )
+      }
+
+      const app = loadedConfig.app
+
+      if (appConfig.isProduction && !process.env.NODE_ENV) {
+        process.env.NODE_ENV = 'production'
+      }
+
+      const stackable = await app.buildStackable({
+        onMissingEnv: this.#fetchServiceUrl,
+        config: this.appConfig.config,
+        context: this.#context
+      })
+      this.stackable = this.#wrapStackable(stackable)
+
+      const metricsConfig = this.#context.metricsConfig
+      if (metricsConfig !== false) {
+        this.#metricsRegistry = await collectMetrics(this.stackable, this.appConfig.id, metricsConfig)
+      }
+
+      this.#updateDispatcher()
+    } catch (err) {
+      if (err.validationErrors) {
+        console.error('Validation errors:', err.validationErrors)
+        process.exit(1)
+      } else {
+        this.#logAndExit(err)
+      }
+    }
+  }
+
+  async start () {
+    if (this.#starting || this.#started) {
+      throw new errors.ApplicationAlreadyStartedError()
+    }
+
+    this.#starting = true
+
+    try {
+      await this.stackable.init()
+    } catch (err) {
+      this.#logAndExit(err)
+    }
+
+    if (this.#watch) {
+      const watchConfig = await this.stackable.getWatchConfig()
+      if (watchConfig.enabled !== false) {
+        /* c8 ignore next 4 */
+        this.#debouncedRestart = debounce(() => {
+          this.stackable.log({ message: 'files changed', level: 'debug' })
+          this.emit('changed')
+        }, 100) // debounce restart for 100ms
+
+        this.#startFileWatching(watchConfig)
+      }
+    }
+
+    const listen = !!this.appConfig.useHttp
+    try {
+      await this.stackable.start({ listen })
+      this.#listening = listen
+      /* c8 ignore next 5 */
+    } catch (err) {
+      this.stackable.log({ message: err.message, level: 'debug' })
+      this.#starting = false
+      throw err
+    }
+
+    this.#started = true
+    this.#starting = false
+    this.emit('start')
+  }
+
+  async stop () {
+    if (!this.#started || this.#starting) {
+      throw new errors.ApplicationNotStartedError()
+    }
+
+    await this.#stopFileWatching()
+    await this.stackable.stop()
+
+    this.#started = false
+    this.#starting = false
+    this.#listening = false
+    this.emit('stop')
+  }
+
+  async listen () {
+    // This server is not an entrypoint or already listened in start. Behave as no-op.
+    if (!this.appConfig.entrypoint || this.appConfig.useHttp || this.#listening) {
+      return
+    }
+
+    await this.stackable.start({ listen: true })
+  }
+
+  async getMetrics ({ format }) {
+    if (!this.#metricsRegistry) return null
+
+    return format === 'json' ? this.#metricsRegistry.getMetricsAsJSON() : this.#metricsRegistry.metrics()
+  }
+
+  #fetchServiceUrl (key, { parent, context: service }) {
+    if (service.localServiceEnvVars.has(key)) {
+      return service.localServiceEnvVars.get(key)
+    } else if (!key.endsWith('_URL') || !parent.serviceId) {
+      return null
+    }
+
+    return getServiceUrl(parent.serviceId)
+  }
+
+  #startFileWatching (watch) {
+    if (this.#fileWatcher) {
+      return
+    }
+
+    const fileWatcher = new FileWatcher({
+      path: watch.path,
+      /* c8 ignore next 2 */
+      allowToWatch: watch?.allow,
+      watchIgnore: watch?.ignore || []
+    })
+
+    fileWatcher.on('update', this.#debouncedRestart)
+
+    fileWatcher.startWatching()
+    this.stackable.log({ message: 'start watching files', level: 'debug' })
+    this.#fileWatcher = fileWatcher
+  }
+
+  async #stopFileWatching () {
+    const watcher = this.#fileWatcher
+
+    if (watcher) {
+      this.stackable.log({ message: 'stop watching files', level: 'debug' })
+      await watcher.stopWatching()
+      this.#fileWatcher = null
+    }
+  }
+
+  #logAndExit (err) {
+    // Runtime logs here with console.error because stackable is not initialized
+    console.error(err.message)
+    process.exit(1)
+  }
+
+  #wrapStackable (stackable) {
+    const newStackable = {}
+    for (const method of Object.keys(defaultStackable)) {
+      newStackable[method] = stackable[method] ? stackable[method].bind(stackable) : defaultStackable[method]
+    }
+    return newStackable
+  }
+
+  #updateDispatcher () {
+    const telemetryConfig = this.#context.telemetryConfig
+    const telemetryId = telemetryConfig?.serviceName
+
+    const interceptor = dispatch => {
+      return function InterceptedDispatch (opts, handler) {
+        if (telemetryId) {
+          opts.headers = {
+            ...opts.headers,
+            'x-plt-telemetry-id': telemetryId
+          }
+        }
+        return dispatch(opts, handler)
+      }
+    }
+
+    const dispatcher = getGlobalDispatcher().compose(interceptor)
+
+    setGlobalDispatcher(dispatcher)
+  }
+}
+
+module.exports = { PlatformaticApp }

package/lib/worker/default-stackable.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const defaultStackable = {
+  init: () => {},
+  start: () => {
+    throw new Error('Stackable start not implemented')
+  },
+  stop: () => {},
+  build: () => {},
+  getUrl: () => null,
+  updateContext: () => {},
+  getConfig: () => null,
+  getEnv: () => null,
+  getInfo: () => null,
+  getDispatchFunc: () => null,
+  getOpenapiSchema: () => null,
+  getGraphqlSchema: () => null,
+  getMeta: () => ({}),
+  collectMetrics: () => ({
+    defaultMetrics: true,
+    httpMetrics: true
+  }),
+  inject: () => {
+    throw new Error('Stackable inject not implemented')
+  },
+  log: ({ message }) => {
+    console.log(message)
+  },
+  getBootstrapDependencies: () => [],
+  getWatchConfig: () => ({ enabled: false })
+}
+
+module.exports = defaultStackable

package/lib/worker/itc.js

@@ -0,0 +1,162 @@
+'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')
+
+async function safeHandleInITC (worker, fn) {
+  try {
+    // Make sure to catch when the worker exits, otherwise we're stuck forever
+    const ac = new AbortController()
+    let exitCode
+
+    const response = await Unpromise.race([
+      fn(),
+      once(worker, 'exit', { signal: ac.signal }).then(([code]) => {
+        exitCode = code
+      })
+    ])
+
+    if (typeof exitCode === 'number') {
+      throw new errors.ServiceExitedError(worker[kId], exitCode)
+    } else {
+      ac.abort()
+    }
+
+    return response
+  } catch (error) {
+    if (!error.handlerError) {
+      throw error
+    }
+
+    if (error.handlerErrorCode && !error.handlerError.code) {
+      error.handlerError.code = error.handlerErrorCode
+    }
+
+    throw error.handlerError
+  }
+}
+
+async function sendViaITC (worker, name, message) {
+  return safeHandleInITC(worker, () => worker[kITC].send(name, message))
+}
+
+async function waitEventFromITC (worker, event) {
+  return safeHandleInITC(worker, () => once(worker[kITC], event))
+}
+
+function setupITC (app, service, dispatcher) {
+  const itc = new ITC({
+    name: app.appConfig.id + '-worker',
+    port: parentPort,
+    handlers: {
+      async start () {
+        const status = app.getStatus()
+
+        if (status === 'starting') {
+          await once(app, 'start')
+        } else {
+          await app.start()
+        }
+
+        if (service.entrypoint) {
+          await app.listen()
+        }
+
+        const url = app.stackable.getUrl()
+
+        const dispatchFunc = await app.stackable.getDispatchFunc()
+        dispatcher.replaceServer(url ?? dispatchFunc)
+
+        return service.entrypoint ? url : null
+      },
+
+      async stop () {
+        const status = app.getStatus()
+
+        if (status === 'starting') {
+          await once(app, 'start')
+        }
+
+        if (status !== 'stopped') {
+          await app.stop()
+        }
+
+        dispatcher.interceptor.close()
+        itc.close()
+      },
+
+      async build () {
+        return app.stackable.build()
+      },
+
+      getStatus () {
+        return app.getStatus()
+      },
+
+      getServiceInfo () {
+        return app.stackable.getInfo()
+      },
+
+      async getServiceConfig () {
+        const current = await app.stackable.getConfig()
+        // Remove all undefined keys from the config
+        return JSON.parse(JSON.stringify(current))
+      },
+
+      async getServiceEnv () {
+        // Remove all undefined keys from the config
+        return JSON.parse(JSON.stringify({ ...process.env, ...(await app.stackable.getEnv()) }))
+      },
+
+      async getServiceOpenAPISchema () {
+        try {
+          return await app.stackable.getOpenapiSchema()
+        } catch (err) {
+          throw new errors.FailedToRetrieveOpenAPISchemaError(service.id, err.message)
+        }
+      },
+
+      async getServiceGraphQLSchema () {
+        try {
+          return await app.stackable.getGraphqlSchema()
+        } catch (err) {
+          throw new errors.FailedToRetrieveGraphQLSchemaError(service.id, err.message)
+        }
+      },
+
+      async getServiceMeta () {
+        try {
+          return await app.stackable.getMeta()
+        } catch (err) {
+          throw new errors.FailedToRetrieveMetaError(service.id, err.message)
+        }
+      },
+
+      async getMetrics (format) {
+        try {
+          return await app.getMetrics({ format })
+        } catch (err) {
+          throw new errors.FailedToRetrieveMetricsError(service.id, err.message)
+        }
+      },
+
+      inject (injectParams) {
+        return app.stackable.inject(injectParams)
+      }
+    }
+  })
+
+  app.on('changed', () => {
+    itc.notify('changed')
+  })
+
+  return itc
+}
+
+module.exports = { sendViaITC, setupITC, waitEventFromITC }

package/lib/worker/main.js

@@ -0,0 +1,135 @@
+'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,
+  executeWithTimeout,
+  ensureLoggableError
+} = require('@platformatic/utils')
+const { kId, kITC } = require('./symbols')
+
+process.on('uncaughtException', handleUnhandled.bind(null, 'uncaught exception'))
+process.on('unhandledRejection', handleUnhandled.bind(null, 'unhandled rejection'))
+
+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}.`
+  )
+
+  executeWithTimeout(app?.stop(), 1000)
+    .catch()
+    .finally(() => {
+      process.exit(1)
+    })
+}
+
+function createLogger () {
+  const destination = new MessagePortWritable({ port: workerData.loggingPort })
+  const loggerInstance = pino({ level: 'trace', name: workerData.serviceConfig.id }, destination)
+
+  Reflect.defineProperty(process, 'stdout', { value: createPinoWritable(loggerInstance, 'info') })
+  Reflect.defineProperty(process, 'stderr', { value: createPinoWritable(loggerInstance, 'error') })
+
+  return loggerInstance
+}
+
+async function main () {
+  if (config.preload) {
+    await import(pathToFileURL(config.preload))
+  }
+
+  const service = workerData.serviceConfig
+
+  // 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 globalDispatcher = new Agent({
+    ...config.undici,
+    interceptors
+  }).compose(composedInterceptors)
+
+  setGlobalDispatcher(globalDispatcher)
+
+  // Setup mesh networker
+  const threadDispatcher = wire({ port: parentPort, useNetwork: service.useHttp, timeout: true })
+
+  // If the service is an entrypoint and runtime server config is defined, use it.
+  let serverConfig = null
+  if (config.server && service.entrypoint) {
+    serverConfig = config.server
+  } else if (service.useHttp) {
+    serverConfig = {
+      port: 0,
+      hostname: '127.0.0.1',
+      keepAliveTimeout: 5000
+    }
+  }
+
+  let telemetryConfig = config.telemetry
+  if (telemetryConfig) {
+    telemetryConfig = {
+      ...telemetryConfig,
+      serviceName: `${telemetryConfig.serviceName}-${service.id}`
+    }
+  }
+
+  // Create the application
+  app = new PlatformaticApp(
+    service,
+    telemetryConfig,
+    config.logger,
+    serverConfig,
+    config.metrics,
+    !!config.managementApi,
+    !!config.watch
+  )
+
+  await app.init()
+
+  // Setup interaction with parent port
+  const itc = setupITC(app, service, threadDispatcher)
+
+  // Get the dependencies
+  const dependencies = config.autoload ? await app.getBootstrapDependencies() : []
+  itc.notify('init', { dependencies })
+  itc.listen()
+
+  globalThis[kITC] = itc
+}
+
+// No need to catch this because there is the unhadledRejection handler on top.
+main()

package/lib/worker/metrics.js

@@ -0,0 +1,106 @@
+'use strict'
+
+const os = require('node:os')
+const { eventLoopUtilization } = require('node:perf_hooks').performance
+const { Registry, Gauge, collectDefaultMetrics } = require('prom-client')
+const collectHttpMetrics = require('@platformatic/http-metrics')
+
+async function collectMetrics (stackable, serviceId, opts = {}) {
+  const registry = new Registry()
+  const metricsConfig = await stackable.collectMetrics({ registry })
+
+  const labels = opts.labels ?? {}
+  registry.setDefaultLabels({ ...labels, serviceId })
+
+  if (metricsConfig.defaultMetrics) {
+    collectDefaultMetrics({ register: registry })
+    collectEluMetric(registry)
+  }
+
+  if (metricsConfig.httpMetrics) {
+    collectHttpMetrics(registry, {
+      customLabels: ['telemetry_id'],
+      getCustomLabels: (req) => {
+        const telemetryId = req.headers['x-plt-telemetry-id'] ?? 'unknown'
+        return { telemetry_id: telemetryId }
+      }
+    })
+
+    // TODO: check if it's a nodejs environment
+    // Needed for the Meraki metrics
+    collectHttpMetrics(registry, {
+      customLabels: ['telemetry_id'],
+      getCustomLabels: (req) => {
+        const telemetryId = req.headers['x-plt-telemetry-id'] ?? 'unknown'
+        return { telemetry_id: telemetryId }
+      },
+      histogram: {
+        name: 'http_request_all_duration_seconds',
+        help: 'request duration in seconds summary for all requests',
+        collect: function () {
+          process.nextTick(() => this.reset())
+        },
+      },
+      summary: {
+        name: 'http_request_all_summary_seconds',
+        help: 'request duration in seconds histogram for all requests',
+        collect: function () {
+          process.nextTick(() => this.reset())
+        },
+      },
+    })
+  }
+
+  return registry
+}
+
+function collectEluMetric (register) {
+  let startELU = eventLoopUtilization()
+  const eluMetric = new Gauge({
+    name: 'nodejs_eventloop_utilization',
+    help: 'The event loop utilization as a fraction of the loop time. 1 is fully utilized, 0 is fully idle.',
+    collect: () => {
+      const endELU = eventLoopUtilization()
+      const result = eventLoopUtilization(endELU, startELU).utilization
+      eluMetric.set(result)
+      startELU = endELU
+    },
+    registers: [register],
+  })
+  register.registerMetric(eluMetric)
+
+  let previousIdleTime = 0
+  let previousTotalTime = 0
+  const cpuMetric = new Gauge({
+    name: 'process_cpu_percent_usage',
+    help: 'The process CPU percent usage.',
+    collect: () => {
+      const cpus = os.cpus()
+      let idleTime = 0
+      let totalTime = 0
+
+      cpus.forEach(cpu => {
+        for (const type in cpu.times) {
+          totalTime += cpu.times[type]
+          if (type === 'idle') {
+            idleTime += cpu.times[type]
+          }
+        }
+      })
+
+      const idleDiff = idleTime - previousIdleTime
+      const totalDiff = totalTime - previousTotalTime
+
+      const usagePercent = 100 - ((100 * idleDiff) / totalDiff)
+      const roundedUsage = Math.round(usagePercent * 100) / 100
+      cpuMetric.set(roundedUsage)
+
+      previousIdleTime = idleTime
+      previousTotalTime = totalTime
+    },
+    registers: [register],
+  })
+  register.registerMetric(cpuMetric)
+}
+
+module.exports = { collectMetrics }

package/lib/worker/symbols.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const kConfig = Symbol.for('plt.runtime.config')
+const kId = Symbol.for('plt.runtime.id') // This is also used to detect if we are running in a Platformatic runtime thread
+const kITC = Symbol.for('plt.runtime.itc')
+
+module.exports = { kConfig, kId, kITC }