@platformatic/runtime 3.4.1 → 3.5.0

package/lib/worker/app.js

@@ -1,278 +0,0 @@
-'use strict'
-
-const { existsSync } = require('node:fs')
-const { EventEmitter } = require('node:events')
-const { resolve } = require('node:path')
-const { ConfigManager } = require('@platformatic/config')
-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
-
-      // Before returning the base application, check if there is any file we recognize
-      // and the user just forgot to specify in the configuration.
-      if (!appConfig.config) {
-        const candidate = ConfigManager.listConfigFiles().find(f => existsSync(resolve(appConfig.path, f)))
-
-        if (candidate) {
-          appConfig.config = resolve(appConfig.path, candidate)
-        }
-      }
-
-      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) {
-    console.error(err)
-    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

@@ -1,33 +0,0 @@
-'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/metrics.js

@@ -1,122 +0,0 @@
-'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 httpRequestCallbacks = []
-  const httpResponseCallbacks = []
-
-  const metricsConfig = await stackable.collectMetrics({
-    registry,
-    startHttpTimer: options => httpRequestCallbacks.forEach(cb => cb(options)),
-    endHttpTimer: options => httpResponseCallbacks.forEach(cb => cb(options))
-  })
-
-  const labels = opts.labels ?? {}
-  registry.setDefaultLabels({ ...labels, serviceId })
-
-  if (metricsConfig.defaultMetrics) {
-    collectDefaultMetrics({ register: registry })
-    collectEluMetric(registry)
-  }
-
-  if (metricsConfig.httpMetrics) {
-    {
-      const { startTimer, endTimer } = collectHttpMetrics(registry, {
-        customLabels: ['telemetry_id'],
-        getCustomLabels: (req) => {
-          const telemetryId = req.headers?.['x-plt-telemetry-id'] ?? 'unknown'
-          return { telemetry_id: telemetryId }
-        }
-      })
-      httpRequestCallbacks.push(startTimer)
-      httpResponseCallbacks.push(endTimer)
-    }
-
-    {
-      // TODO: check if it's a nodejs environment
-      // Needed for the Meraki metrics
-      const { startTimer, endTimer } = 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())
-          },
-        },
-      })
-      httpRequestCallbacks.push(startTimer)
-      httpResponseCallbacks.push(endTimer)
-    }
-  }
-
-  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/runtime.mjs

@@ -1,54 +0,0 @@
-#! /usr/bin/env node
-
-import { readFile } from 'node:fs/promises'
-import commist from 'commist'
-import { join } from 'desm'
-import isMain from 'es-main'
-import helpMe from 'help-me'
-import parseArgs from 'minimist'
-import { startCommand } from './index.js'
-import { compile as compileCmd } from './lib/compile.js'
-
-export const compile = compileCmd
-
-const help = helpMe({
-  dir: join(import.meta.url, 'help'),
-  // the default
-  ext: '.txt',
-})
-
-const program = commist({ maxDistance: 2 })
-
-program.register('help', help.toStdout)
-program.register('help start', help.toStdout.bind(null, ['start']))
-program.register('help compile', help.toStdout.bind(null, ['compile']))
-program.register('start', startCommand)
-program.register('compile', compile)
-
-export async function run (argv) {
-  const args = parseArgs(argv, {
-    alias: {
-      v: 'version',
-    },
-  })
-
-  if (args.version) {
-    console.log('v' + JSON.parse(await readFile(join(import.meta.url, 'package.json'), 'utf-8')).version)
-    process.exit(0)
-  }
-
-  /* c8 ignore next 4 */
-  return {
-    output: await program.parseAsync(argv),
-    help,
-  }
-}
-
-if (isMain(import.meta)) {
-  try {
-    await run(process.argv.slice(2))
-  } catch (err) {
-    console.error(err)
-    process.exit(1)
-  }
-}