@platformatic/runtime 3.4.1 → 3.5.1

package/lib/logger.js

@@ -1,55 +1,57 @@
-'use strict'
+import { buildPinoFormatters, buildPinoTimestamp } from '@platformatic/foundation'
+import { isatty } from 'node:tty'
+import pino from 'pino'
+import pretty from 'pino-pretty'
+
+export { abstractLogger } from '@platformatic/foundation'
+
+const customPrettifiers = {
+  name (name, _, obj) {
+    if (typeof obj.worker !== 'undefined') {
+      name += ':' + obj.worker
+      obj.worker = undefined // Do not show the worker in a separate line
+    }
 
-const { join } = require('node:path')
-const { isatty } = require('node:tty')
+    return name
+  }
+}
 
-const pino = require('pino')
-const pretty = require('pino-pretty')
+// Create the runtime logger
+export async function createLogger (config) {
+  const loggerConfig = { ...config.logger, transport: undefined }
+  if (config.logger.base === null) {
+    loggerConfig.base = undefined
+  }
 
-function createLogger (config, runtimeLogsDir) {
-  const loggerConfig = { ...config.logger }
-  const cliStream = isatty(1) ? pretty() : pino.destination(1)
+  let cliStream
 
-  if (!config.managementApi) {
-    return [pino(loggerConfig, cliStream), cliStream]
+  if (config.logger.transport) {
+    cliStream = pino.transport(config.logger.transport)
+  } else {
+    cliStream = isatty(1) ? pretty({ customPrettifiers }) : pino.destination(1)
   }
 
-  const multiStream = pino.multistream([
-    { stream: cliStream, level: loggerConfig.level || 'info' },
-  ])
+  if (loggerConfig.formatters) {
+    loggerConfig.formatters = buildPinoFormatters(loggerConfig.formatters)
+  }
 
-  if (loggerConfig.transport) {
-    const transport = pino.transport(loggerConfig.transport)
-    multiStream.add({ level: loggerConfig.level || 'info', stream: transport })
+  if (loggerConfig.timestamp) {
+    loggerConfig.timestamp = buildPinoTimestamp(loggerConfig.timestamp)
   }
 
-  if (config.managementApi) {
-    const logsFileMb = 5
-    const logsLimitMb = config.managementApi?.logs?.maxSize || 200
+  if (!config.managementApi) {
+    return [pino(loggerConfig, cliStream), cliStream]
+  }
 
-    let logsLimitCount = Math.ceil(logsLimitMb / logsFileMb) - 1
-    if (logsLimitCount < 1) {
-      logsLimitCount = 1
-    }
+  const multiStream = pino.multistream([{ stream: cliStream, level: loggerConfig.level }])
+
+  const logsFileMb = 5
+  const logsLimitMb = config.managementApi?.logs?.maxSize || 200
 
-    const pinoRoll = pino.transport({
-      target: 'pino-roll',
-      options: {
-        file: join(runtimeLogsDir, 'logs'),
-        mode: 0o600,
-        size: logsFileMb + 'm',
-        mkdir: true,
-        fsync: true,
-        limit: {
-          count: logsLimitCount,
-        },
-      },
-    })
-
-    multiStream.add({ level: 'trace', stream: pinoRoll })
+  let logsLimitCount = Math.ceil(logsLimitMb / logsFileMb) - 1
+  if (logsLimitCount < 1) {
+    logsLimitCount = 1
   }
 
-  return [pino({ level: 'trace' }, multiStream), multiStream]
+  return [pino(loggerConfig, multiStream), multiStream]
 }
-
-module.exports = { createLogger }

package/lib/management-api.js

@@ -1,27 +1,24 @@
-'use strict'
-
-const { platform, tmpdir } = require('node:os')
-const { join } = require('node:path')
-const { createDirectory, safeRemove } = require('@platformatic/utils')
-
-const fastify = require('fastify')
-const ws = require('ws')
-
-const errors = require('./errors')
-const { getRuntimeLogsDir } = require('./utils')
+import fastifyAccepts from '@fastify/accepts'
+import fastifyWebsocket from '@fastify/websocket'
+import { createDirectory, safeRemove } from '@platformatic/foundation'
+import fastify from 'fastify'
+import { platform, tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { createWebSocketStream } from 'ws'
 
 const PLATFORMATIC_TMP_DIR = join(tmpdir(), 'platformatic', 'runtimes')
 
-async function managementApiPlugin (app, opts) {
-  app.log.warn(
-    'Runtime Management API is in the experimental stage. ' +
-      'The feature is not subject to semantic versioning rules. ' +
-      'Non-backward compatible changes or removal may occur in any future release. ' +
-      'Use of the feature is not recommended in production environments.'
-  )
+export async function managementApiPlugin (app, opts) {
+  app.register(fastifyAccepts)
 
   const runtime = opts.runtime
 
+  app.get('/status', async () => {
+    const status = runtime.getRuntimeStatus()
+    return { status }
+  })
+
   app.get('/metadata', async () => {
     return runtime.getRuntimeMetadata()
   })
@@ -35,62 +32,62 @@ async function managementApiPlugin (app, opts) {
   })
 
   app.post('/stop', async () => {
-    app.log.debug('stop services')
-    await runtime.close(true)
+    app.log.debug('stop applications')
+    await runtime.close()
   })
 
   app.post('/restart', async () => {
-    app.log.debug('restart services')
+    app.log.debug('restart applications')
     await runtime.restart()
   })
 
-  app.get('/services', async () => {
-    return runtime.getServices()
+  app.get('/applications', async () => {
+    return runtime.getApplications()
   })
 
-  app.get('/services/:id', async request => {
+  app.get('/applications/:id', async request => {
     const { id } = request.params
-    app.log.debug('get service details', { id })
-    return runtime.getServiceDetails(id)
+    app.log.debug('get application details', { id })
+    return runtime.getApplicationDetails(id)
   })
 
-  app.get('/services/:id/config', async request => {
+  app.get('/applications/:id/config', async request => {
     const { id } = request.params
-    app.log.debug('get service config', { id })
-    return runtime.getServiceConfig(id)
+    app.log.debug('get application config', { id })
+    return runtime.getApplicationConfig(id)
   })
 
-  app.get('/services/:id/env', async request => {
+  app.get('/applications/:id/env', async request => {
     const { id } = request.params
-    app.log.debug('get service config', { id })
-    return runtime.getServiceEnv(id)
+    app.log.debug('get application config', { id })
+    return runtime.getApplicationEnv(id)
   })
 
-  app.get('/services/:id/openapi-schema', async request => {
+  app.get('/applications/:id/openapi-schema', async request => {
     const { id } = request.params
     app.log.debug('get openapi-schema', { id })
-    return runtime.getServiceOpenapiSchema(id)
+    return runtime.getApplicationOpenapiSchema(id)
   })
 
-  app.get('/services/:id/graphql-schema', async request => {
+  app.get('/applications/:id/graphql-schema', async request => {
     const { id } = request.params
     app.log.debug('get graphql-schema', { id })
-    return runtime.getServiceGraphqlSchema(id)
+    return runtime.getApplicationGraphqlSchema(id)
   })
 
-  app.post('/services/:id/start', async request => {
+  app.post('/applications/:id/start', async request => {
     const { id } = request.params
-    app.log.debug('start service', { id })
-    await runtime.startService(id)
+    app.log.debug('start application', { id })
+    await runtime.startApplication(id)
   })
 
-  app.post('/services/:id/stop', async request => {
+  app.post('/applications/:id/stop', async request => {
     const { id } = request.params
-    app.log.debug('stop service', { id })
-    await runtime._stopService(id)
+    app.log.debug('stop application', { id })
+    await runtime.stopApplication(id)
   })
 
-  app.all('/services/:id/proxy/*', async (request, reply) => {
+  app.all('/applications/:id/proxy/*', async (request, reply) => {
     const { id, '*': requestUrl } = request.params
     app.log.debug('proxy request', { id, requestUrl })
 
@@ -115,6 +112,36 @@ async function managementApiPlugin (app, opts) {
     reply.code(res.statusCode).headers(res.headers).send(res.body)
   })
 
+  app.post('/applications/:id/pprof/start', async (request, reply) => {
+    const { id } = request.params
+    app.log.debug('start profiling', { id })
+
+    const options = request.body || {}
+    await runtime.startApplicationProfiling(id, options)
+    reply.code(200).send({})
+  })
+
+  app.post('/applications/:id/pprof/stop', async (request, reply) => {
+    const { id } = request.params
+    app.log.debug('stop profiling', { id })
+
+    const profileData = await runtime.stopApplicationProfiling(id)
+    reply.type('application/octet-stream').code(200).send(profileData)
+  })
+
+  app.get('/metrics', { logLevel: 'debug' }, async (req, reply) => {
+    const accepts = req.accepts()
+
+    if (!accepts.type('text/plain') && accepts.type('application/json')) {
+      const { metrics } = await runtime.getMetrics('json')
+      return metrics
+    }
+
+    reply.type('text/plain')
+    const { metrics } = await runtime.getMetrics('text')
+    return metrics
+  })
+
   app.get('/metrics/live', { websocket: true }, async socket => {
     const cachedMetrics = runtime.getCachedMetrics()
     if (cachedMetrics.length > 0) {
@@ -139,93 +166,57 @@ async function managementApiPlugin (app, opts) {
   })
 
   app.get('/logs/live', { websocket: true }, async (socket, req) => {
-    const startLogId = req.query.start ? parseInt(req.query.start) : null
-
-    if (startLogId) {
-      const logIds = await runtime.getLogIds()
-      if (!logIds.includes(startLogId)) {
-        throw new errors.LogFileNotFound(startLogId)
-      }
-    }
-
-    const stream = ws.createWebSocketStream(socket)
-    runtime.pipeLogsStream(stream, req.log, startLogId)
-  })
-
-  app.get('/logs/indexes', async req => {
-    const returnAllIds = req.query.all === 'true'
-
-    if (returnAllIds) {
-      const runtimesLogsIds = await runtime.getAllLogIds()
-      return runtimesLogsIds
-    }
-
-    const runtimeLogsIds = await runtime.getLogIds()
-    return { indexes: runtimeLogsIds }
-  })
-
-  app.get('/logs/all', async (req, reply) => {
-    const runtimePID = parseInt(req.query.pid) || process.pid
-
-    const logsIds = await runtime.getLogIds(runtimePID)
-    const startLogId = logsIds.at(0)
-    const endLogId = logsIds.at(-1)
-
-    reply.hijack()
-
-    runtime.pipeLogsStream(reply.raw, req.log, startLogId, endLogId, runtimePID)
+    runtime.addLoggerDestination(createWebSocketStream(socket))
   })
+}
 
-  app.get('/logs/:id', async req => {
-    const logId = parseInt(req.params.id)
-    const runtimePID = parseInt(req.query.pid) || process.pid
+export async function startManagementApi (runtime) {
+  const runtimePID = process.pid
 
-    const logIds = await runtime.getLogIds(runtimePID)
-    if (!logIds || !logIds.includes(logId)) {
-      throw new errors.LogFileNotFound(logId)
-    }
+  const runtimePIDDir = join(PLATFORMATIC_TMP_DIR, runtimePID.toString())
+  if (platform() !== 'win32') {
+    await createDirectory(runtimePIDDir, true)
+  }
 
-    const logFileStream = await runtime.getLogFileStream(logId, runtimePID)
-    return logFileStream
-  })
-}
+  let socketPath = null
+  if (platform() === 'win32') {
+    socketPath = '\\\\.\\pipe\\platformatic-' + runtimePID.toString()
+  } else {
+    socketPath = join(runtimePIDDir, 'socket')
+  }
 
-async function startManagementApi (runtime, configManager) {
-  const runtimePID = process.pid
+  const managementApi = fastify()
+  managementApi.register(fastifyWebsocket)
+  managementApi.register(managementApiPlugin, { runtime, prefix: '/api/v1' })
 
-  try {
-    const runtimePIDDir = join(PLATFORMATIC_TMP_DIR, runtimePID.toString())
+  managementApi.addHook('onClose', async () => {
     if (platform() !== 'win32') {
-      await createDirectory(runtimePIDDir, true)
+      await safeRemove(runtimePIDDir)
     }
+  })
 
-    const runtimeLogsDir = getRuntimeLogsDir(configManager.dirname, process.pid)
-    await createDirectory(runtimeLogsDir, true)
+  // When the runtime closes, close the management API as well
+  runtime.on('closed', managementApi.close.bind(managementApi))
 
-    let socketPath = null
-    if (platform() === 'win32') {
-      socketPath = '\\\\.\\pipe\\platformatic-' + runtimePID.toString()
-    } else {
-      socketPath = join(runtimePIDDir, 'socket')
-    }
+  /*
+    If runtime are started multiple times in a short
+    period of time (like in tests), there is a chance that the pipe is still in use
+    as the manament API server is closed after the runtime is closed (see event handler above).
 
-    const managementApi = fastify()
-    managementApi.register(require('@fastify/websocket'))
-    managementApi.register(managementApiPlugin, { runtime, prefix: '/api/v1' })
-
-    managementApi.addHook('onClose', async () => {
-      if (platform() !== 'win32') {
-        await safeRemove(runtimePIDDir)
+    Since it's a very rare case, we simply retry couple of times.
+  */
+  for (let i = 0; i < 5; i++) {
+    try {
+      await managementApi.listen({ path: socketPath })
+      break
+    } catch (e) {
+      if (i === 5) {
+        throw e
       }
-    })
 
-    await managementApi.listen({ path: socketPath })
-    return managementApi
-    /* c8 ignore next 4 */
-  } catch (err) {
-    console.error(err)
-    process.exit(1)
+      await sleep(100)
+    }
   }
-}
 
-module.exports = { startManagementApi, managementApiPlugin }
+  return managementApi
+}

package/lib/prom-server.js

@@ -1,46 +1,232 @@
-'use strict'
+import fastifyAccepts from '@fastify/accepts'
+import fastifyBasicAuth from '@fastify/basic-auth'
+import { loadModule } from '@platformatic/foundation'
+import fastify from 'fastify'
+import { createRequire } from 'node:module'
+import { resolve } from 'node:path'
 
-const fastify = require('fastify')
+const DEFAULT_HOSTNAME = '0.0.0.0'
+const DEFAULT_PORT = 9090
+const DEFAULT_METRICS_ENDPOINT = '/metrics'
+const DEFAULT_READINESS_ENDPOINT = '/ready'
+const DEFAULT_READINESS_SUCCESS_STATUS_CODE = 200
+const DEFAULT_READINESS_SUCCESS_BODY = 'OK'
+const DEFAULT_READINESS_FAIL_STATUS_CODE = 500
+const DEFAULT_READINESS_FAIL_BODY = 'ERR'
+const DEFAULT_LIVENESS_ENDPOINT = '/status'
+const DEFAULT_LIVENESS_SUCCESS_STATUS_CODE = 200
+const DEFAULT_LIVENESS_SUCCESS_BODY = 'OK'
+const DEFAULT_LIVENESS_FAIL_STATUS_CODE = 500
+const DEFAULT_LIVENESS_FAIL_BODY = 'ERR'
 
-async function startPrometheusServer (runtime, opts) {
-  const host = opts.hostname ?? '0.0.0.0'
-  const port = opts.port ?? 9090
-  const metricsEndpoint = opts.endpoint ?? '/metrics'
+async function checkReadiness (runtime) {
+  const workers = await runtime.getWorkers()
+
+  // Make sure there is at least one started worker
+  const applications = new Set()
+  const started = new Set()
+  for (const worker of Object.values(workers)) {
+    applications.add(worker.application)
+
+    if (worker.status === 'started') {
+      started.add(worker.application)
+    }
+  }
+
+  if (started.size !== applications.size) {
+    return { status: false }
+  }
+
+  // perform custom readiness checks, get custom response content if any
+  const checks = await runtime.getCustomReadinessChecks()
+
+  let response
+  const status = Object.values(checks).every(check => {
+    if (typeof check === 'boolean') {
+      return check
+    } else if (typeof check === 'object') {
+      response = check
+      return check.status
+    }
+    return false
+  })
+
+  return { response, status }
+}
+
+async function checkLiveness (runtime) {
+  const { status: ready, response: readinessResponse } = await checkReadiness(runtime)
+  if (!ready) {
+    return { status: false, readiness: readinessResponse }
+  }
+  // TODO test, doc
+  // in case of readiness check failure, if custom readiness response is set, we return the readiness check response on health check endpoint
+
+  const checks = await runtime.getCustomHealthChecks()
+
+  let response
+  const status = Object.values(checks).every(check => {
+    if (typeof check === 'boolean') {
+      return check
+    } else if (typeof check === 'object') {
+      response = check
+      return check.status
+    }
+    return false
+  })
+
+  return { response, status }
+}
+
+export async function startPrometheusServer (runtime, opts) {
+  if (opts.enabled === false) {
+    return
+  }
+  const host = opts.hostname ?? DEFAULT_HOSTNAME
+  const port = opts.port ?? DEFAULT_PORT
+  const metricsEndpoint = opts.endpoint ?? DEFAULT_METRICS_ENDPOINT
   const auth = opts.auth ?? null
 
   const promServer = fastify({ name: 'Prometheus server' })
+  promServer.register(fastifyAccepts)
 
   let onRequestHook
   if (auth) {
     const { username, password } = auth
 
-    await promServer.register(require('@fastify/basic-auth'), {
+    await promServer.register(fastifyBasicAuth, {
       validate: function (user, pass, req, reply, done) {
         if (username !== user || password !== pass) {
           return reply.code(401).send({ message: 'Unauthorized' })
         }
         return done()
-      },
+      }
     })
     onRequestHook = promServer.basicAuth
   }
 
+  const readinessEndpoint = opts.readiness?.endpoint ?? DEFAULT_READINESS_ENDPOINT
+  const livenessEndpoint = opts.liveness?.endpoint ?? DEFAULT_LIVENESS_ENDPOINT
+
+  promServer.route({
+    url: '/',
+    method: 'GET',
+    logLevel: 'warn',
+    handler (req, reply) {
+      reply.type('text/plain')
+      let response = `Hello from Platformatic Prometheus Server!\nThe metrics are available at ${metricsEndpoint}.`
+
+      if (opts.readiness !== false) {
+        response += `\nThe readiness endpoint is available at ${readinessEndpoint}.`
+      }
+
+      if (opts.liveness !== false) {
+        response += `\nThe liveness endpoint is available at ${livenessEndpoint}.`
+      }
+
+      return response
+    }
+  })
+
   promServer.route({
     url: metricsEndpoint,
     method: 'GET',
     logLevel: 'warn',
     onRequest: onRequestHook,
     handler: async (req, reply) => {
-      reply.type('text/plain')
-      const { metrics } = await runtime.getMetrics('text')
-      return metrics
-    },
+      const accepts = req.accepts()
+      const reqType = !accepts.type('text/plain') && accepts.type('application/json') ? 'json' : 'text'
+      if (reqType === 'text') {
+        reply.type('text/plain')
+      }
+      return (await runtime.getMetrics(reqType)).metrics
+    }
   })
 
+  if (opts.readiness !== false) {
+    const successStatusCode = opts.readiness?.success?.statusCode ?? DEFAULT_READINESS_SUCCESS_STATUS_CODE
+    const successBody = opts.readiness?.success?.body ?? DEFAULT_READINESS_SUCCESS_BODY
+    const failStatusCode = opts.readiness?.fail?.statusCode ?? DEFAULT_READINESS_FAIL_STATUS_CODE
+    const failBody = opts.readiness?.fail?.body ?? DEFAULT_READINESS_FAIL_BODY
+
+    promServer.route({
+      url: readinessEndpoint,
+      method: 'GET',
+      logLevel: 'warn',
+      handler: async (req, reply) => {
+        reply.type('text/plain')
+
+        const { status, response } = await checkReadiness(runtime)
+
+        if (typeof response === 'boolean') {
+          if (status) {
+            reply.status(successStatusCode).send(successBody)
+          } else {
+            reply.status(failStatusCode).send(failBody)
+          }
+        } else if (typeof response === 'object') {
+          const { status, body, statusCode } = response
+          if (status) {
+            reply.status(statusCode || successStatusCode).send(body || successBody)
+          } else {
+            reply.status(statusCode || failStatusCode).send(body || failBody)
+          }
+        } else if (!response) {
+          if (status) {
+            reply.status(successStatusCode).send(successBody)
+          } else {
+            reply.status(failStatusCode).send(failBody)
+          }
+        }
+      }
+    })
+  }
+
+  if (opts.liveness !== false) {
+    const successStatusCode = opts.liveness?.success?.statusCode ?? DEFAULT_LIVENESS_SUCCESS_STATUS_CODE
+    const successBody = opts.liveness?.success?.body ?? DEFAULT_LIVENESS_SUCCESS_BODY
+    const failStatusCode = opts.liveness?.fail?.statusCode ?? DEFAULT_LIVENESS_FAIL_STATUS_CODE
+    const failBody = opts.liveness?.fail?.body ?? DEFAULT_LIVENESS_FAIL_BODY
+
+    promServer.route({
+      url: livenessEndpoint,
+      method: 'GET',
+      logLevel: 'warn',
+      handler: async (req, reply) => {
+        reply.type('text/plain')
+
+        const { status, response, readiness } = await checkLiveness(runtime)
+
+        if (typeof response === 'boolean') {
+          if (status) {
+            reply.status(successStatusCode).send(successBody)
+          } else {
+            reply.status(failStatusCode).send(readiness?.body || failBody)
+          }
+        } else if (typeof response === 'object') {
+          const { status, body, statusCode } = response
+          if (status) {
+            reply.status(statusCode || successStatusCode).send(body || successBody)
+          } else {
+            reply.status(statusCode || failStatusCode).send(body || readiness?.body || failBody)
+          }
+        } else if (!response) {
+          if (status) {
+            reply.status(successStatusCode).send(successBody)
+          } else {
+            reply.status(failStatusCode).send(readiness?.body || failBody)
+          }
+        }
+      }
+    })
+  }
+
+  const require = createRequire(resolve(import.meta.filename))
+  for (const pluginPath of opts.plugins ?? []) {
+    const plugin = await loadModule(require, pluginPath)
+    await promServer.register(plugin)
+  }
+
   await promServer.listen({ port, host })
   return promServer
 }
-
-module.exports = {
-  startPrometheusServer,
-}