@platformatic/service 2.74.3 → 3.0.0-alpha.2

package/lib/plugins/clients.js

@@ -1,16 +0,0 @@
-'use strict'
-
-const fp = require('fastify-plugin')
-const client = require('@platformatic/client')
-
-async function setupClients (app, opts) {
-  for (const { path, url, serviceId, name, schema, type, fullRequest, fullResponse, validateResponse } of opts) {
-    if (path) {
-      app.register(require(path), { url, serviceId })
-    } else {
-      app.register(client, { url, serviceId, name, path: schema, type, fullRequest, fullResponse, validateResponse })
-    }
-  }
-}
-
-module.exports = fp(setupClients)

package/lib/plugins/metrics.js

@@ -1,244 +0,0 @@
-'use strict'
-
-const os = require('node:os')
-const http = require('node:http')
-const { eventLoopUtilization } = require('node:perf_hooks').performance
-const fastify = require('fastify')
-const fp = require('fastify-plugin')
-
-const metricsPlugin = fp(async function (app, opts = {}) {
-  const promClient = require('prom-client')
-
-  const register = new promClient.Registry()
-
-  const defaultMetrics = opts.defaultMetrics ?? { enabled: true }
-
-  if (opts.labels) {
-    const labels = opts.labels ?? {}
-    register.setDefaultLabels(labels)
-  }
-
-  app.register(require('fastify-metrics'), {
-    defaultMetrics: {
-      ...defaultMetrics,
-      register,
-    },
-    endpoint: null,
-    name: 'metrics',
-    clearRegisterOnInit: false,
-    promClient: {
-      ...promClient,
-      register,
-    },
-    routeMetrics: {
-      enabled: true,
-      customLabels: {
-        // TODO: check if this is set in prom
-        telemetry_id: (req) => req.headers['x-plt-telemetry-id'] ?? 'unknown',
-      },
-      overrides: {
-        histogram: {
-          name: 'http_request_duration_seconds',
-          registers: [register],
-        },
-        summary: {
-          name: 'http_request_summary_seconds',
-          registers: [register],
-        },
-      },
-    },
-  })
-
-  app.register(fp(async (app) => {
-    const httpLatencyMetric = new app.metrics.client.Summary({
-      name: 'http_request_all_summary_seconds',
-      help: 'request duration in seconds summary for all requests',
-      collect: () => {
-        process.nextTick(() => httpLatencyMetric.reset())
-      },
-      registers: [register],
-    })
-
-    const ignoredMethods = ['HEAD', 'OPTIONS', 'TRACE', 'CONNECT']
-    const timers = new WeakMap()
-    app.addHook('onRequest', async (req) => {
-      if (ignoredMethods.includes(req.method)) return
-      const timer = httpLatencyMetric.startTimer()
-      timers.set(req, timer)
-    })
-    app.addHook('onResponse', async (req) => {
-      if (ignoredMethods.includes(req.method)) return
-      const timer = timers.get(req)
-      if (timer) {
-        timer()
-        timers.delete(req)
-      }
-    })
-  }, {
-    encapsulate: false,
-  }))
-
-  if (defaultMetrics.enabled) {
-    app.register(async (app) => {
-      let startELU = eventLoopUtilization()
-      const eluMetric = new app.metrics.client.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],
-      })
-      app.metrics.client.register.registerMetric(eluMetric)
-
-      let previousIdleTime = 0
-      let previousTotalTime = 0
-      const cpuMetric = new app.metrics.client.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],
-      })
-      app.metrics.client.register.registerMetric(cpuMetric)
-    })
-  }
-
-  function cleanMetrics () {
-    const httpMetrics = ['http_request_duration_seconds', 'http_request_summary_seconds', 'http_request_all_summary_seconds']
-    const metrics = app.metrics.client.register._metrics
-    for (const metricName in metrics) {
-      if (defaultMetrics.enabled || httpMetrics.includes(metricName)) {
-        delete metrics[metricName]
-      }
-    }
-  }
-
-  app.addHook('onClose', async () => {
-    cleanMetrics()
-  })
-}, {
-  encapsulate: false,
-})
-
-// This is a global httpServer to match global
-// prometheus. It's an antipattern, so do
-// not use it elsewhere.
-let httpServer = null
-
-async function createMetricsServer (app, hostname, port) {
-  if (httpServer && httpServer.address().port !== port) {
-    await closeMetricsServer()
-  }
-
-  if (!httpServer) {
-    httpServer = http.createServer()
-    httpServer.listen(port, hostname)
-    httpServer.unref()
-  }
-
-  const promServer = fastify({
-    name: 'Prometheus server',
-    serverFactory: (handler) => {
-      httpServer.removeAllListeners('request')
-      httpServer.removeAllListeners('clientError')
-      httpServer.on('request', handler)
-      return httpServer
-    },
-    loggerInstance: app.log.child({ name: 'prometheus' }),
-  })
-
-  app.addHook('onClose', async () => {
-    await promServer.close()
-  })
-
-  return promServer
-}
-
-async function closeMetricsServer () {
-  if (httpServer) {
-    await new Promise((resolve) => httpServer.close(resolve))
-    httpServer = null
-  }
-}
-
-module.exports = fp(async function (app, opts) {
-  const server = opts.server ?? 'own'
-  const hostname = opts.hostname ?? '0.0.0.0'
-  const port = opts.port ?? 9090
-  const metricsEndpoint = opts.endpoint ?? '/metrics'
-  const auth = opts.auth ?? null
-
-  app.register(metricsPlugin, opts)
-
-  let metricsServer = app
-  if (server === 'own') {
-    metricsServer = await createMetricsServer(app, hostname, port)
-  } else {
-    await closeMetricsServer()
-  }
-
-  if (server !== 'hide') {
-    let onRequestHook
-    if (auth) {
-      const { username, password } = auth
-
-      await metricsServer.register(require('@fastify/basic-auth'), {
-        validate: function (user, pass, req, reply, done) {
-          if (username !== user || password !== pass) {
-            return reply.code(401).send({ message: 'Unauthorized' })
-          }
-          return done()
-        },
-      })
-      onRequestHook = metricsServer.basicAuth
-    }
-
-    metricsServer.register(require('@fastify/accepts'))
-
-    metricsServer.route({
-      url: metricsEndpoint,
-      method: 'GET',
-      logLevel: 'warn',
-      onRequest: onRequestHook,
-      handler: async (req, reply) => {
-        const promRegistry = app.metrics.client.register
-        const accepts = req.accepts()
-        if (!accepts.type('text/plain') && accepts.type('application/json')) {
-          return promRegistry.getMetricsAsJSON()
-        }
-        reply.type('text/plain')
-        return promRegistry.metrics()
-      },
-    })
-  }
-
-  if (server === 'own') {
-    await metricsServer.ready()
-  }
-})

package/lib/plugins/typescript.js

@@ -1,20 +0,0 @@
-'use strict'
-
-const fp = require('fastify-plugin')
-const compiler = require('@platformatic/ts-compiler')
-const { extractTypeScriptCompileOptionsFromConfig } = require('../compile')
-
-async function setupTsCompiler (app, opts) {
-  const configManager = app.platformatic.configManager
-  const config = configManager.current
-  const workingDir = opts?.context?.directory ?? configManager.dirname
-
-  await compiler.compile({
-    ...extractTypeScriptCompileOptionsFromConfig(config),
-    cwd: workingDir,
-    clean: false,
-    logger: app.log,
-  })
-}
-
-module.exports = fp(setupTsCompiler)

package/lib/start.js

@@ -1,190 +0,0 @@
-'use strict'
-
-const { readFile } = require('fs/promises')
-const close = require('close-with-grace')
-const {
-  loadConfig,
-  ConfigManager,
-  printConfigValidationErrors,
-  printAndExitLoadConfigError
-} = require('@platformatic/config')
-const { addLoggerToTheConfig, isDocker } = require('./utils.js')
-const { randomUUID } = require('crypto')
-const { fastify } = require('fastify')
-const { features } = require('@platformatic/utils')
-
-async function adjustHttpsKeyAndCert (arg) {
-  if (typeof arg === 'string') {
-    return arg
-  }
-
-  if (!Array.isArray(arg)) {
-    // { path: pathToKeyOrCert }
-    return readFile(arg.path)
-  }
-
-  // Array of strings or objects.
-  for (let i = 0; i < arg.length; ++i) {
-    arg[i] = await adjustHttpsKeyAndCert(arg[i])
-  }
-
-  return arg
-}
-
-async function createServer (serverContext) {
-  const { app, configManager, context } = serverContext
-  const config = configManager.current
-  let fastifyOptions = {}
-
-  if (config.server) {
-    // override hostname if it's docker
-    if (await isDocker()) {
-      config.server.hostname = '0.0.0.0'
-    }
-    fastifyOptions = {
-      ...config.server
-    }
-  }
-
-  Object.assign(fastifyOptions, context?.fastifyOptions ?? {})
-
-  fastifyOptions.genReqId = function (req) {
-    return randomUUID()
-  }
-  const root = fastify(fastifyOptions)
-  root.decorate('platformatic', { configManager, config })
-  await root.register(app, { context })
-  if (!root.hasRoute({ url: '/', method: 'GET' }) && !root.hasRoute({ url: '/*', method: 'GET' })) {
-    await root.register(require('./root-endpoint'))
-  }
-
-  root.decorate('url', {
-    getter () {
-      return serverContext.url
-    }
-  })
-
-  return root
-}
-async function buildConfigManager (options, app) {
-  const loggerInstance = options.server?.loggerInstance
-  if (loggerInstance) {
-    delete options.server.loggerInstance
-    options.server ||= {}
-    options.server.logger = { level: loggerInstance.level }
-  }
-
-  let configManager = options.configManager
-  if (!configManager) {
-    // instantiate a new config manager from current options
-    configManager = new ConfigManager({ ...app.configManagerConfig, source: options })
-    await configManager.parseAndValidate()
-  }
-
-  if (loggerInstance) {
-    configManager.current.server ||= {}
-    delete configManager.current.server.logger
-    configManager.current.server.loggerInstance = loggerInstance
-  }
-  return configManager
-}
-
-async function buildServer (options, app, context) {
-  const configManager = await buildConfigManager(options, app)
-  const config = configManager.current
-
-  // The server now can be not present, so we might need to add logger
-  addLoggerToTheConfig(config)
-
-  // options is a path
-  if (typeof options === 'string') {
-    options = config
-  }
-
-  if (options.server) {
-    if (options.server.https) {
-      options.server.https.key = await adjustHttpsKeyAndCert(options.server.https.key)
-      options.server.https.cert = await adjustHttpsKeyAndCert(options.server.https.cert)
-    }
-  }
-
-  const serverContext = {
-    app: typeof app === 'function' ? app : app.app,
-    configManager,
-    context
-  }
-  const handler = await createServer(serverContext)
-  handler.start = async function () {
-    serverContext.url = await handler.listen({
-      host: options.server?.hostname || '127.0.0.1',
-      port: options.server?.port || 0,
-      reusePort: features.node.reusePort && context?.isProduction
-    })
-    return serverContext.url
-  }
-  configManager.on('error', function (err) {
-    /* c8 ignore next 1 */
-    handler.log.error({ err }, 'error reloading the configuration')
-  })
-
-  return handler
-}
-
-async function start (appType, _args) {
-  /* c8 ignore next 55 */
-  let configManager = null
-  try {
-    configManager = (await loadConfig({}, _args, appType)).configManager
-  } catch (err) {
-    if (err.validationErrors) {
-      printConfigValidationErrors(err)
-      process.exit(1)
-    } else {
-      throw err
-    }
-  }
-
-  const config = configManager.current
-
-  const _transformConfig = configManager._transformConfig.bind(configManager)
-  configManager._transformConfig = function () {
-    const config = configManager.current
-    addLoggerToTheConfig(config)
-    return _transformConfig(config)
-  }
-
-  let app = null
-
-  try {
-    // Set the location of the config
-    app = await buildServer({ ...config, configManager }, appType)
-    await app.start()
-  } catch (err) {
-    printAndExitLoadConfigError(err)
-  }
-
-  close(async ({ signal, err }) => {
-    // Windows does not support trapping signals
-    if (err) {
-      app.log.error(
-        {
-          err: {
-            message: err.message,
-            stack: err.stack
-          }
-        },
-        'exiting'
-      )
-    } else if (signal) {
-      app.log.info({ signal }, 'received signal')
-    }
-
-    // Weird coverage issue in c8
-    /* c8 ignore next 2 */
-    await app.close()
-  })
-}
-
-module.exports.buildConfigManager = buildConfigManager
-module.exports.buildServer = buildServer
-module.exports.start = start

package/service.mjs

@@ -1,71 +0,0 @@
-#! /usr/bin/env node
-
-import commist from 'commist'
-import parseArgs from 'minimist'
-import isMain from 'es-main'
-import helpMe from 'help-me'
-import { readFile } from 'fs/promises'
-import { join } from 'desm'
-import { printAndExitLoadConfigError } from '@platformatic/config'
-import { buildCompileCmd } from './lib/compile.js'
-import { generateJsonSchemaConfig } from './lib/gen-schema.js'
-import { generateTypes } from './lib/gen-types.mjs'
-import { createService } from './lib/create.mjs'
-
-import platformaticService from './index.js'
-
-const help = helpMe({
-  dir: join(import.meta.url, 'help'),
-  // the default
-  ext: '.txt',
-})
-
-function wrapCommand (fn) {
-  return async function (...args) {
-    try {
-      return await fn(...args)
-      /* c8 ignore next 3 */
-    } catch (err) {
-      printAndExitLoadConfigError(err)
-    }
-  }
-}
-
-const program = commist({ maxDistance: 2 })
-
-program.register('help', help.toStdout)
-program.register('help start', help.toStdout.bind(null, ['start']))
-
-program.register('start', (argv) => {
-  /* c8 ignore next 1 */
-  platformaticService.start(platformaticService, argv).catch(printAndExitLoadConfigError)
-})
-
-program.register('create', wrapCommand(createService))
-program.register('compile', buildCompileCmd(platformaticService))
-program.register('types', wrapCommand(generateTypes))
-program.register('schema config', wrapCommand(generateJsonSchemaConfig))
-program.register('schema', help.toStdout.bind(null, ['schema']))
-
-export async function runService (argv) {
-  const args = parseArgs(argv, {
-    alias: {
-      v: 'version',
-    },
-  })
-
-  /* c8 ignore next 4 */
-  if (args.version) {
-    console.log('v' + JSON.parse(await readFile(join(import.meta.url, 'package.json'), 'utf-8')).version)
-    process.exit(0)
-  }
-
-  return {
-    output: await program.parseAsync(argv),
-    help,
-  }
-}
-
-if (isMain(import.meta)) {
-  await runService(process.argv.splice(2))
-}