@platformatic/service 3.4.1 → 3.5.0

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/stackable.js

@@ -1,306 +0,0 @@
-'use strict'
-
-const { dirname } = require('node:path')
-const { printSchema } = require('graphql')
-const pino = require('pino')
-const httpMetrics = require('@platformatic/fastify-http-metrics')
-const { extractTypeScriptCompileOptionsFromConfig } = require('./compile')
-const { compile } = require('@platformatic/ts-compiler')
-const { deepmerge } = require('@platformatic/utils')
-
-class ServiceStackable {
-  constructor (options) {
-    this.app = null
-    this._init = options.init
-    this.stackable = options.stackable
-    this.metricsRegistry = null
-
-    this.configManager = options.configManager
-    this.context = options.context ?? {}
-    this.context.stackable = this
-
-    this.configManager.on('error', err => {
-      /* c8 ignore next */
-      this.stackable.log({
-        message: 'error reloading the configuration' + err,
-        level: 'error'
-      })
-    })
-
-    this.#updateConfig()
-
-    // Setup globals
-    this.registerGlobals({
-      setOpenapiSchema: this.setOpenapiSchema.bind(this),
-      setGraphqlSchema: this.setGraphqlSchema.bind(this),
-      setBasePath: this.setBasePath.bind(this)
-    })
-  }
-
-  async init () {
-    this.#initLogger()
-
-    if (this.app === null) {
-      this.app = await this._init()
-
-      if (this.metricsRegistry) {
-        this.#setHttpMetrics()
-      }
-    }
-    return this.app
-  }
-
-  async start (options = {}) {
-    await this.init()
-
-    if (options.listen === false) {
-      await this.app.ready()
-      return
-    }
-    await this.app.start()
-  }
-
-  async stop () {
-    if (this.app === null) return
-    await this.app.close()
-  }
-
-  async build () {
-    this.#initLogger()
-    const typeScriptCompileOptions = extractTypeScriptCompileOptionsFromConfig(this.configManager.current)
-    const cwd = dirname(this.configManager.fullPath)
-    const compileOptions = {
-      ...typeScriptCompileOptions,
-      cwd,
-      logger: this.logger
-    }
-    if (!(await compile(compileOptions))) {
-      throw new Error(`Failed to compile ${cwd}`)
-    }
-  }
-
-  getUrl () {
-    return this.app !== null ? this.app.url : null
-  }
-
-  async getInfo () {
-    const type = this.stackable.configType
-    const version = this.stackable.configManagerConfig.version ?? null
-    return { type, version }
-  }
-
-  async getConfig () {
-    const config = Object.assign({}, this.configManager.current)
-    config.server = Object.assign({}, config.server)
-    const logger = config.server.loggerInstance
-
-    if (logger) {
-      config.server.logger = {}
-
-      if (logger.level) {
-        config.server.logger.level = logger.level
-      }
-    }
-
-    delete config.server.loggerInstance
-
-    return config
-  }
-
-  async getEnv () {
-    return this.configManager.env
-  }
-
-  getMeta () {
-    const config = this.configManager.current
-
-    return {
-      composer: {
-        prefix: config.basePath ?? this.basePath ?? this.context?.serviceId,
-        wantsAbsoluteUrls: false,
-        needsRootRedirect: false
-      }
-    }
-  }
-
-  async getWatchConfig () {
-    const config = this.configManager.current
-
-    const enabled = config.watch?.enabled !== false && config.plugins !== undefined
-
-    return {
-      enabled,
-      path: dirname(this.configManager.fullPath),
-      allow: config.watch?.allow,
-      ignore: config.watch?.ignore
-    }
-  }
-
-  async getDispatchFunc () {
-    await this.init()
-    return this.app
-  }
-
-  async getOpenapiSchema () {
-    await this.init()
-    await this.app.ready()
-    return this.app.swagger ? this.app.swagger() : null
-  }
-
-  async getGraphqlSchema () {
-    await this.init()
-    await this.app.ready()
-    return this.app.graphql ? printSchema(this.app.graphql.schema) : null
-  }
-
-  async collectMetrics ({ registry }) {
-    this.metricsRegistry = registry
-
-    return {
-      defaultMetrics: true,
-      httpMetrics: false
-    }
-  }
-
-  async inject (injectParams) {
-    await this.init()
-
-    const { statusCode, statusMessage, headers, body } = await this.app.inject(injectParams)
-    return { statusCode, statusMessage, headers, body }
-  }
-
-  async log (options = {}) {
-    await this.init()
-
-    const logLevel = options.level ?? 'info'
-
-    const message = options.message
-    if (!message) return
-
-    this.app.log[logLevel](message)
-  }
-
-  async updateContext (context) {
-    this.context = { ...this.context, ...context }
-    this.#updateConfig()
-  }
-
-  setOpenapiSchema (schema) {
-    this.openapiSchema = schema
-  }
-
-  setGraphqlSchema (schema) {
-    this.graphqlSchema = schema
-  }
-
-  setBasePath (basePath) {
-    this.basePath = basePath
-  }
-
-  registerGlobals (globals) {
-    globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, globals)
-  }
-
-  #setHttpMetrics () {
-    this.app.register(httpMetrics, {
-      registry: this.metricsRegistry,
-      customLabels: ['telemetry_id'],
-      getCustomLabels: req => {
-        const telemetryId = req.headers['x-plt-telemetry-id'] ?? 'unknown'
-        return { telemetry_id: telemetryId }
-      }
-    })
-
-    this.app.register(httpMetrics, {
-      registry: this.metricsRegistry,
-      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())
-        }
-      }
-    })
-  }
-
-  #updateConfig () {
-    if (!this.context) return
-
-    const { serviceId, telemetryConfig, metricsConfig, serverConfig, hasManagementApi, isEntrypoint, isProduction } =
-      this.context
-
-    const config = this.configManager.current
-
-    if (telemetryConfig) {
-      config.telemetry = telemetryConfig
-    }
-    if (metricsConfig) {
-      config.metrics = metricsConfig
-    }
-    if (serverConfig) {
-      config.server = deepmerge(config.server ?? {}, serverConfig ?? {})
-    }
-
-    if ((hasManagementApi && config.metrics === undefined) || config.metrics) {
-      const labels = config.metrics?.labels || {}
-      config.metrics = {
-        server: 'hide',
-        defaultMetrics: { enabled: isEntrypoint },
-        ...config.metrics,
-        labels: { serviceId, ...labels }
-      }
-    }
-
-    if (!isEntrypoint) {
-      config.server = config.server ?? {}
-      config.server.trustProxy = true
-    }
-
-    if (isProduction) {
-      if (config.plugins) {
-        config.plugins.typescript = false
-      }
-      config.watch = { enabled: false }
-    }
-
-    this.configManager.update(config)
-  }
-
-  #initLogger () {
-    if (this.configManager.current.server?.loggerInstance) {
-      this.logger = this.configManager.current.server?.loggerInstance
-      return
-    }
-
-    this.configManager.current.server ??= {}
-    this.loggerConfig = deepmerge(this.context.loggerConfig ?? {}, this.configManager.current.server?.logger ?? {})
-
-    const pinoOptions = {
-      level: this.loggerConfig?.level ?? 'trace'
-    }
-
-    if (this.context?.serviceId) {
-      pinoOptions.name = this.context.serviceId
-    }
-
-    this.logger = pino(pinoOptions)
-
-    // Only one of logger and loggerInstance should be set
-    delete this.configManager.current.server.logger
-    this.configManager.current.server.loggerInstance = this.logger
-  }
-}
-
-module.exports = { ServiceStackable }