@platformatic/runtime 3.55.0 → 3.57.0

package/config.d.ts

@@ -333,6 +333,33 @@ export type PlatformaticRuntimeConfig = {
         enabled?: boolean | string;
         hostname?: string;
         endpoint?: string;
+        https?: {
+          allowHTTP1?: boolean;
+          key:
+            | string
+            | {
+                path?: string;
+              }
+            | (
+                | string
+                | {
+                    path?: string;
+                  }
+              )[];
+          cert:
+            | string
+            | {
+                path?: string;
+              }
+            | (
+                | string
+                | {
+                    path?: string;
+                  }
+              )[];
+          requestCert?: boolean;
+          rejectUnauthorized?: boolean;
+        };
         auth?: {
           username: string;
           password: string;
@@ -471,6 +498,14 @@ export type PlatformaticRuntimeConfig = {
              * The path to write the traces to. Only for file exporter.
              */
             path?: string;
+            /**
+             * The OTLP transport protocol to use. Only for the otlp exporter. Defaults to http.
+             */
+            protocol?: "http" | "grpc";
+            /**
+             * Alias for protocol. Only for the otlp exporter. Defaults to http.
+             */
+            transport?: "http" | "grpc";
             [k: string]: unknown;
           };
           additionalProperties?: never;
@@ -496,6 +531,14 @@ export type PlatformaticRuntimeConfig = {
              * The path to write the traces to. Only for file exporter.
              */
             path?: string;
+            /**
+             * The OTLP transport protocol to use. Only for the otlp exporter. Defaults to http.
+             */
+            protocol?: "http" | "grpc";
+            /**
+             * Alias for protocol. Only for the otlp exporter. Defaults to http.
+             */
+            transport?: "http" | "grpc";
             [k: string]: unknown;
           };
           additionalProperties?: never;

package/index.d.ts

@@ -1,6 +1,7 @@
 import { FastifyError } from '@fastify/error'
 import { Configuration, ConfigurationOptions, logFatalError, parseArgs } from '@platformatic/foundation'
 import { BaseGenerator } from '@platformatic/generators'
+import { PlatformaticGlobal } from '@platformatic/globals'
 import { JSONSchemaType } from 'ajv'
 import * as colorette from 'colorette'
 import { Logger } from 'pino'
@@ -27,6 +28,12 @@ export interface ApplicationsCommands {
   help: Record<string, string | (() => string)>
 }
 
+export interface LoopbackMessagingOptions {
+  logger?: Logger
+  mount?: boolean
+  runtimeConfig?: { messagingTimeout?: number; [key: string]: unknown }
+}
+
 export namespace errors {
   export const RuntimeExitedError: () => FastifyError
   export const UnknownRuntimeAPICommandError: (command: string) => FastifyError
@@ -61,7 +68,6 @@ export namespace symbols {
   export const kWorkerStatus: unique symbol
   export const kWorkerHealthSignals: unique symbol
   export const kStderrMarker: string
-  export const kInterceptors: unique symbol
   export const kWorkersBroadcast: unique symbol
 }
 
@@ -191,3 +197,8 @@ export declare function transform (
 ): Promise<RuntimeConfiguration>
 
 export declare function loadApplicationsCommands (): Promise<ApplicationsCommands>
+
+export declare function setupLoopbackMessaging (
+  targetId: string,
+  options?: LoopbackMessagingOptions
+): PlatformaticGlobal['messaging'] & { unmount: () => void }

package/index.js

@@ -176,6 +176,7 @@ export async function create (configOrRoot, sourceOrConfig, context) {
 export { prepareApplication, transform, wrapInRuntimeConfig } from './lib/config.js'
 export * as errors from './lib/errors.js'
 export { RuntimeGenerator as Generator, WrappedGenerator } from './lib/generator.js'
+export { setupLoopbackMessaging } from './lib/loopback-messaging.js'
 export { Runtime } from './lib/runtime.js'
 export { schema } from './lib/schema.js'
 export * from './lib/version.js'

package/lib/config.js

@@ -18,8 +18,7 @@ import {
   InspectorHostError,
   InspectorPortError,
   InvalidArgumentError,
-  InvalidEntrypointError,
-  MissingEntrypointError
+  InvalidEntrypointError
 } from './errors.js'
 import { schema } from './schema.js'
 import { upgrade } from './upgrade.js'
@@ -438,15 +437,8 @@ export async function transform (config, _, context) {
     }
   }
 
-  if (!hasValidEntrypoint && !context.allowMissingEntrypoint) {
-    if (config.entrypoint) {
-      throw new InvalidEntrypointError(config.entrypoint)
-    } else if (applications.length >= 1) {
-      throw new MissingEntrypointError()
-    }
-    // If there are no applications, and no entrypoint it's an empty app.
-    // It won't start, but we should be able to parse and operate on it,
-    // like adding other applications.
+  if (!hasValidEntrypoint && config.entrypoint && !context.allowMissingEntrypoint) {
+    throw new InvalidEntrypointError(config.entrypoint)
   }
 
   if (typeof config.metrics === 'boolean') {

package/lib/errors.js

@@ -49,6 +49,10 @@ export const ApplicationStartTimeoutError = createError(
   `${ERROR_PREFIX}_APPLICATION_START_TIMEOUT`,
   "Application with id '%s' failed to start in %dms."
 )
+export const ApplicationDependencyNotFoundError = createError(
+  `${ERROR_PREFIX}_APPLICATION_DEPENDENCY_NOT_FOUND`,
+  'Application dependency %s not found. Available applications are: %s'
+)
 export const ApplicationsDependenciesCycleError = createError(
   `${ERROR_PREFIX}_APPLICATIONS_DEPENDENCIES_CYCLE`,
   'Detected a cycle in the applications dependencies: %s'

package/lib/generator.js

@@ -19,17 +19,6 @@ import { transform } from './config.js'
 import { schema } from './schema.js'
 import { getArrayDifference } from './utils.js'
 
-const wrappableProperties = {
-  logger: {
-    level: '{PLT_SERVER_LOGGER_LEVEL}'
-  },
-  server: {
-    hostname: '{PLT_SERVER_HOSTNAME}',
-    port: '{PORT}'
-  },
-  managementApi: '{PLT_MANAGEMENT_API}'
-}
-
 const engines = {
   node: '>=22.19.0'
 }
@@ -42,13 +31,36 @@ const NoApplicationNamedError = createError(
 )
 const NoEntryPointError = createError(`${ERROR_PREFIX}_NO_ENTRYPOINT`, 'No entrypoint had been defined.')
 
+function getRuntimeWrappableProperties (skipServer) {
+  const wrappableProperties = {
+    logger: {
+      level: '{PLT_SERVER_LOGGER_LEVEL}'
+    },
+    managementApi: '{PLT_MANAGEMENT_API}'
+  }
+
+  if (!skipServer) {
+    wrappableProperties.server = {
+      hostname: '{PLT_SERVER_HOSTNAME}',
+      port: '{PORT}'
+    }
+  }
+
+  return wrappableProperties
+}
+
 function getRuntimeBaseEnvVars (config) {
-  return {
-    PLT_SERVER_HOSTNAME: '127.0.0.1',
-    PORT: config.port || 3042,
-    PLT_SERVER_LOGGER_LEVEL: config.logLevel || 'info',
-    PLT_MANAGEMENT_API: true
+  const env = {}
+
+  if (!config.skipServer) {
+    env.PLT_SERVER_HOSTNAME = '127.0.0.1'
+    env.PORT = config.port || 3042
   }
+
+  env.PLT_SERVER_LOGGER_LEVEL = config.logLevel || 'info'
+  env.PLT_MANAGEMENT_API = true
+
+  return env
 }
 
 export class RuntimeGenerator extends BaseGenerator {
@@ -195,7 +207,7 @@ export class RuntimeGenerator extends BaseGenerator {
         path: this.config.autoload || this.applicationsFolder,
         exclude: ['docs']
       },
-      ...wrappableProperties
+      ...getRuntimeWrappableProperties(this.config.skipServer)
     }
 
     return config
@@ -251,13 +263,15 @@ export class RuntimeGenerator extends BaseGenerator {
       return
     }
 
-    // port
-    this.questions.push({
-      type: 'input',
-      name: 'port',
-      default: 3042,
-      message: 'What port do you want to use?'
-    })
+    if (!this.config.skipServer) {
+      // port
+      this.questions.push({
+        type: 'input',
+        name: 'port',
+        default: 3042,
+        message: 'What port do you want to use?'
+      })
+    }
   }
 
   setApplicationsDirectory () {
@@ -611,7 +625,7 @@ export class WrappedGenerator extends BaseGenerator {
   async #createConfigFile () {
     const config = {
       $schema: `https://schemas.platformatic.dev/${this.module}/${this.platformaticVersion}.json`,
-      runtime: wrappableProperties
+      runtime: getRuntimeWrappableProperties(this.config.skipServer)
     }
 
     this.addFile({

package/lib/loopback-messaging.js

@@ -0,0 +1,78 @@
+import { abstractLogger } from '@platformatic/foundation'
+import { getMessaging, removeGlobals, updateGlobals } from '@platformatic/globals'
+import { MessageChannel } from 'node:worker_threads'
+import { MessagingITC } from './worker/messaging.js'
+
+class LoopbackMessagingITC extends MessagingITC {
+  #application
+  #channel
+
+  constructor (id, application, runtimeConfig, logger, channel) {
+    super(id, runtimeConfig, logger)
+
+    this.#application = application
+    this.#channel = channel
+    this.addSource(channel)
+  }
+
+  // Force the next worker to be the channel
+  _getNextWorker () {
+    return { application: this.#application, channel: this.#channel }
+  }
+}
+
+class LoopbackMessaging extends LoopbackMessagingITC {
+  #target
+  #channel
+  #previousGlobals
+
+  constructor (targetId, config, logger) {
+    const channel = new MessageChannel()
+
+    super('loopback-messaging', targetId, config, logger, channel.port1)
+    this.#channel = channel
+    this.#target = new LoopbackMessagingITC(targetId, 'loopback-messaging', config, logger, channel.port2)
+  }
+
+  mount () {
+    this.#previousGlobals = getMessaging({ throwOnMissing: false })
+
+    updateGlobals({
+      messaging: {
+        handle: this.#target.handle.bind(this.#target),
+        send: this.#target.send.bind(this.#target),
+        notify: this.#target.notify.bind(this.#target)
+      }
+    })
+
+    return this
+  }
+
+  unmount () {
+    if (this.#previousGlobals) {
+      updateGlobals({ messaging: this.#previousGlobals })
+    } else {
+      removeGlobals(['messaging'])
+    }
+
+    this.close()
+    this.#target.close()
+    this.#channel.port1.close()
+    this.#channel.port2.close()
+  }
+}
+
+export function setupLoopbackMessaging (targetId, options) {
+  options ??= {}
+
+  const runtimeConfig = { ...(options.runtimeConfig ?? {}) }
+  runtimeConfig.messagingTimeout ??= 5000
+
+  const messaging = new LoopbackMessaging(targetId, runtimeConfig, options.logger ?? abstractLogger)
+
+  if (options.mount !== false) {
+    messaging.mount()
+  }
+
+  return messaging
+}

package/lib/management-api.js

@@ -9,7 +9,7 @@ import {
 } from '@platformatic/foundation'
 import fastify from 'fastify'
 import { platform, tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { dirname, join } from 'node:path'
 import { setTimeout as sleep } from 'node:timers/promises'
 import { createWebSocketStream } from 'ws'
 import { prepareApplication } from './config.js'
@@ -342,8 +342,8 @@ export async function startManagementApi (runtime, config) {
   const customSocket = typeof config === 'object' ? config?.socket : null
 
   const runtimePIDDir = join(PLATFORMATIC_TMP_DIR, runtimePID.toString())
-  if (platform() !== 'win32' && !customSocket) {
-    await createDirectory(runtimePIDDir, true)
+  if (platform() !== 'win32') {
+    await createDirectory(customSocket ? dirname(customSocket) : runtimePIDDir, typeof customSocket !== 'string')
   }
 
   let socketPath = null

package/lib/prom-server.js

@@ -2,6 +2,7 @@ import fastifyAccepts from '@fastify/accepts'
 import fastifyBasicAuth from '@fastify/basic-auth'
 import { loadModule } from '@platformatic/foundation'
 import fastify from 'fastify'
+import { readFile } from 'node:fs/promises'
 import { createRequire } from 'node:module'
 import { resolve } from 'node:path'
 
@@ -52,6 +53,33 @@ async function checkReadiness (runtime) {
   return { response, status }
 }
 
+async function sanitizeHTTPSArgument (arg) {
+  if (typeof arg === 'string') {
+    return arg
+  } else if (!Array.isArray(arg)) {
+    return readFile(arg.path)
+  }
+
+  const sanitized = []
+  for (const item of arg) {
+    sanitized.push(typeof item === 'string' ? item : await readFile(item.path))
+  }
+
+  return sanitized
+}
+
+async function sanitizeHTTPSOptions (https) {
+  if (!https) {
+    return
+  }
+
+  return {
+    ...https,
+    key: await sanitizeHTTPSArgument(https.key),
+    cert: await sanitizeHTTPSArgument(https.cert)
+  }
+}
+
 async function checkLiveness (runtime) {
   const { status: ready, response: readinessResponse } = await checkReadiness(runtime)
   if (!ready) {
@@ -84,8 +112,9 @@ export async function startPrometheusServer (runtime, opts) {
   const port = opts.port ?? DEFAULT_PORT
   const metricsEndpoint = opts.endpoint ?? DEFAULT_METRICS_ENDPOINT
   const auth = opts.auth ?? null
+  const https = await sanitizeHTTPSOptions(opts.https)
 
-  const promServer = fastify({ name: 'Prometheus server', loggerInstance: runtime.logger })
+  const promServer = fastify({ name: 'Prometheus server', loggerInstance: runtime.logger, https })
   promServer.register(fastifyAccepts)
 
   let onRequestHook

package/lib/runtime.js

@@ -9,6 +9,7 @@ import {
   kTimeout,
   parseMemorySize
 } from '@platformatic/foundation'
+import { getExecutable } from '@platformatic/globals'
 import { ITC } from '@platformatic/itc'
 import { collectProcessMetrics, client as metricsClient } from '@platformatic/metrics'
 import fastify from 'fastify'
@@ -36,7 +37,6 @@ import {
   CannotRemoveEntrypointError,
   InvalidArgumentError,
   MessagingError,
-  MissingEntrypointError,
   MissingPprofCapture,
   RuntimeAbortedError,
   WorkerInterceptorJoinTimeoutError,
@@ -274,14 +274,18 @@ export class Runtime extends EventEmitter {
       await this.init()
     }
 
-    if (typeof this.#config.entrypoint === 'undefined') {
-      throw new MissingEntrypointError()
-    }
     this.#updateStatus('starting')
     this.#createWorkersBroadcastChannel()
 
     try {
-      await this.startApplications(this.getApplicationsIds(), silent)
+      const applications = this.getApplicationsIds()
+      await this.startApplications(applications, silent)
+
+      if (applications.length === 0) {
+        this.#updateStatus('started')
+        await this.close(silent)
+        return
+      }
 
       if (this.#config.inspectorOptions) {
         const { port } = this.#config.inspectorOptions
@@ -327,7 +331,9 @@ export class Runtime extends EventEmitter {
     this.#startHealthMetricsCollectionIfNeeded()
 
     await this.#dynamicWorkersScaler?.start()
-    this.#showUrl()
+    if (this.#url) {
+      this.#showUrl()
+    }
     return this.#url
   }
 
@@ -582,7 +588,7 @@ export class Runtime extends EventEmitter {
 
     // Now, topological sort the applications based on their dependencies.
     // If circular dependencies are detected, an error with proper error code is thrown.
-    applications = topologicalSort(dependencies)
+    applications = topologicalSort(applications, dependencies)
 
     // Group into dependency levels so that each level's dependencies are all
     // in previous levels. Levels are started sequentially, but applications
@@ -1122,6 +1128,10 @@ export class Runtime extends EventEmitter {
   }
 
   async getEntrypointDetails () {
+    if (!this.#entrypointId) {
+      return null
+    }
+
     return this.getApplicationDetails(this.#entrypointId)
   }
 
@@ -1168,6 +1178,10 @@ export class Runtime extends EventEmitter {
   }
 
   async getMetrics (format = 'json') {
+    if (this.#config.metrics === false || this.#config.metrics?.enabled === false) {
+      throw new Error('Metrics are disabled')
+    }
+
     let metrics = null
 
     const applicationRestartMetrics = format === 'json'
@@ -1716,6 +1730,10 @@ export class Runtime extends EventEmitter {
   }
 
   #showUrl () {
+    if (!this.#url) {
+      return
+    }
+
     this.logger.info(`Platformatic is now listening at ${this.#url}`)
   }
 
@@ -1734,7 +1752,7 @@ export class Runtime extends EventEmitter {
         applicationConfig.path = join(this.#root, config.resolvedApplicationsBasePath, id)
 
         if (!existsSync(applicationConfig.path)) {
-          const executable = globalThis.platformatic?.executable ?? 'platformatic'
+          const executable = getExecutable() ?? 'platformatic'
           this.logger.error(
             `The path for application "%s" does not exist. Please run "${executable} resolve" and try again.`,
             id
@@ -2713,6 +2731,12 @@ export class Runtime extends EventEmitter {
 
   async #createWorkersBroadcastChannel () {
     this.#workersBroadcastChannel?.close()
+
+    if (this.#config.applications.length === 0) {
+      this.#workersBroadcastChannel = undefined
+      return
+    }
+
     this.#workersBroadcastChannel = new BroadcastChannel(kWorkersBroadcast)
   }
 

package/lib/utils.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { ApplicationsDependenciesCycleError } from './errors.js'
+import { ApplicationDependencyNotFoundError, ApplicationsDependenciesCycleError } from './errors.js'
 
 export function getArrayDifference (a, b) {
   return a.filter(element => {
@@ -48,13 +48,22 @@ export function topologicalLevels (sorted, graph) {
   return levels
 }
 
-// Graph: Map<string, string[]>
-export function topologicalSort (graph) {
+// valid: string[] | Map<string, string[]>, graph?: Map<string, string[]>
+export function topologicalSort (valid, graph) {
+  if (!graph) {
+    graph = valid
+    valid = Array.from(graph.keys())
+  }
+
   const result = []
   const visited = new Set()
   const path = []
 
   function visit (node) {
+    if (!valid.includes(node)) {
+      throw new ApplicationDependencyNotFoundError(node, valid.join(', '))
+    }
+
     if (visited.has(node)) {
       return
     }

package/lib/worker/controller.js

@@ -8,6 +8,16 @@ import {
   loadConfigurationModule,
   mirrorGlobalDispatcherForBuiltinFetch
 } from '@platformatic/foundation'
+import {
+  getLogger,
+  getOnActiveResourcesEventLoop,
+  getOnHttpStatsConnected,
+  getOnHttpStatsFree,
+  getOnHttpStatsPending,
+  getOnHttpStatsQueued,
+  getOnHttpStatsRunning,
+  getOnHttpStatsSize
+} from '@platformatic/globals'
 import debounce from 'debounce'
 import { EventEmitter } from 'node:events'
 import { existsSync } from 'node:fs'
@@ -17,6 +27,7 @@ import { workerData } from 'node:worker_threads'
 import { getGlobalDispatcher, setGlobalDispatcher } from 'undici'
 import { ApplicationAlreadyStartedError, RuntimeNotStartedError } from '../errors.js'
 import { getApplicationUrl } from '../utils.js'
+import { markAsPlatformaticDispatcher, refreshGlobalDispatcher } from './interceptors.js'
 
 function fetchApplicationUrl (application, key) {
   if (!key.endsWith('_URL') || !application.id) {
@@ -29,7 +40,8 @@ function fetchApplicationUrl (application, key) {
 function handleUnhandled (app, type, err) {
   const label = `worker ${workerData.worker.index} of the application "${workerData.applicationConfig.id}"`
 
-  globalThis.platformatic.logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${type}.`)
+  const logger = getLogger()
+  logger.error({ err: ensureLoggableError(err) }, `The ${label} threw an ${type}.`)
 
   executeWithTimeout(app?.stop(), 1000)
     .catch()
@@ -142,7 +154,8 @@ export class Controller extends EventEmitter {
       }
     } catch (err) {
       if (err.validationErrors) {
-        globalThis.platformatic.logger.error(
+        const logger = getLogger()
+        logger.error(
           { err: ensureLoggableError(err) },
           'The application threw a validation error.'
         )
@@ -193,6 +206,9 @@ export class Controller extends EventEmitter {
 
     try {
       await this.capability.start({ listen })
+      if (refreshGlobalDispatcher()) {
+        this.#updateDispatcher()
+      }
       this.#listening = listen
       /* c8 ignore next 5 */
     } catch (err) {
@@ -244,18 +260,31 @@ export class Controller extends EventEmitter {
 
   async getMetrics ({ format }) {
     const dispatcher = getGlobalDispatcher()
-    if (globalThis.platformatic?.onHttpStatsFree && dispatcher?.stats) {
+    const onHttpStatsFree = getOnHttpStatsFree({ throwOnMissing: false })
+
+    if (onHttpStatsFree && dispatcher?.stats) {
+      // The capability might come from an older version of @platformatic/basic
+      // which registered these globals without the fields tracking, so never throw.
+      const onHttpStatsConnected = getOnHttpStatsConnected({ throwOnMissing: false })
+      const onHttpStatsPending = getOnHttpStatsPending({ throwOnMissing: false })
+      const onHttpStatsQueued = getOnHttpStatsQueued({ throwOnMissing: false })
+      const onHttpStatsRunning = getOnHttpStatsRunning({ throwOnMissing: false })
+      const onHttpStatsSize = getOnHttpStatsSize({ throwOnMissing: false })
+
       for (const url in dispatcher.stats) {
         const { free, connected, pending, queued, running, size } = dispatcher.stats[url]
-        globalThis.platformatic.onHttpStatsFree(url, free || 0)
-        globalThis.platformatic.onHttpStatsConnected(url, connected || 0)
-        globalThis.platformatic.onHttpStatsPending(url, pending || 0)
-        globalThis.platformatic.onHttpStatsQueued(url, queued || 0)
-        globalThis.platformatic.onHttpStatsRunning(url, running || 0)
-        globalThis.platformatic.onHttpStatsSize(url, size || 0)
+        onHttpStatsFree(url, free || 0)
+        onHttpStatsConnected?.(url, connected || 0)
+        onHttpStatsPending?.(url, pending || 0)
+        onHttpStatsQueued?.(url, queued || 0)
+        onHttpStatsRunning?.(url, running || 0)
+        onHttpStatsSize?.(url, size || 0)
       }
     }
-    globalThis.platformatic.onActiveResourcesEventLoop(getActiveResourcesInfo().length)
+    const onActiveResourcesEventLoop = getOnActiveResourcesEventLoop({ throwOnMissing: false })
+    if (onActiveResourcesEventLoop) {
+      onActiveResourcesEventLoop(getActiveResourcesInfo().length)
+    }
     return this.capability.getMetrics({ format })
   }
 
@@ -300,7 +329,8 @@ export class Controller extends EventEmitter {
   }
 
   #logAndThrow (err) {
-    globalThis.platformatic.logger.error(
+    const logger = getLogger()
+    logger.error(
       { err: ensureLoggableError(err) },
       err[kHandledError] ? err.message : 'The application threw an error.'
     )
@@ -326,6 +356,7 @@ export class Controller extends EventEmitter {
 
     const dispatcher = getGlobalDispatcher().compose(interceptor)
 
+    markAsPlatformaticDispatcher(dispatcher)
     setGlobalDispatcher(dispatcher)
     mirrorGlobalDispatcherForBuiltinFetch(dispatcher)
   }
@@ -336,7 +367,8 @@ export class Controller extends EventEmitter {
 
     process.on('newListener', event => {
       if (event === 'uncaughtException' || event === 'unhandledRejection') {
-        globalThis.platformatic.logger.warn(
+        const logger = getLogger()
+        logger.warn(
           `A listener has been added for the "process.${event}" event. This listener will be never triggered as Watt default behavior will kill the process before.\n To disable this behavior, set "exitOnUnhandledErrors" to false in the runtime config.`
         )
       }