@platformatic/runtime 3.63.0-alpha.3 → 3.63.0

package/lib/scheduler.js

@@ -1,176 +1,68 @@
 import { CronJob, validateCronExpression } from 'cron'
 import { setTimeout } from 'node:timers/promises'
 import { request } from 'undici'
-import { DuplicateSchedulerJobError, SchedulerJobNotFoundError } from './errors.js'
 
 export class SchedulerService {
   constructor (schedulerConfig, dispatcher, logger) {
     this.logger = logger
+    this.jobsConfig = []
+    this.cronJobs = []
     this.dispatcher = dispatcher
-    this.jobs = new Map()
-    this.started = false
-
-    for (const config of schedulerConfig) {
-      this.addJob({ ...config, source: 'config' })
-    }
-  }
-
-  addJob (config, executor) {
-    // Skip disabled schedulers
-    if (config.enabled === false) {
-      return null
-    }
-
-    // Validate cron expression
-    const validation = validateCronExpression(config.cron)
-    if (!validation.valid) {
-      throw new Error(`Invalid cron expression "${config.cron}" for scheduler "${config.name}"`)
-    }
-
-    // Set defaults for optional fields
-    const job = {
-      ...config,
-      headers: config.headers || {},
-      body: config.body || {},
-      maxRetries: config.maxRetries ?? 3,
-      source: config.source ?? 'application',
-      paused: false,
-      lastExecutedAt: null,
-      lastStatus: null,
-      cronJob: null,
-      executor
-    }
-
-    if (this.jobs.has(job.name)) {
-      throw new DuplicateSchedulerJobError(job.name)
-    }
-
-    this.jobs.set(job.name, job)
-
-    if (this.started) {
-      this.#startJob(job)
-    }
-
-    return this.#serializeJob(job)
-  }
-
-  start () {
-    this.started = true
-
-    for (const job of this.jobs.values()) {
-      this.#startJob(job)
-    }
-  }
-
-  async stop () {
-    this.started = false
-
-    for (const job of this.jobs.values()) {
-      await this.#stopJob(job)
-    }
-  }
-
-  getJobs () {
-    return Array.from(this.jobs.values(), job => this.#serializeJob(job))
-  }
-
-  // Stops the local cron trigger for a job without removing its configuration.
-  // Used when an external coordinator (e.g. ICC) takes over the scheduling, so
-  // that multiple instances of the same runtime do not execute the job concurrently.
-  async pauseJob (name) {
-    const job = this.#getJobOrThrow(name)
-
-    if (job.paused) {
-      return this.#serializeJob(job)
-    }
-
-    job.paused = true
-    await this.#stopJob(job)
-    this.logger.info(`Scheduler "${name}" paused`)
-    return this.#serializeJob(job)
-  }
-
-  async resumeJob (name) {
-    const job = this.#getJobOrThrow(name)
-
-    if (!job.paused) {
-      return this.#serializeJob(job)
-    }
-
-    job.paused = false
-
-    if (this.started) {
-      this.#startJob(job)
-    }
-
-    this.logger.info(`Scheduler "${name}" resumed`)
-    return this.#serializeJob(job)
+    this.validateCronSchedulers(schedulerConfig)
   }
 
-  async removeApplicationJobs (applicationId) {
-    for (const [name, job] of this.jobs) {
-      if (job.applicationId === applicationId) {
-        await this.#stopJob(job)
-        this.jobs.delete(name)
+  validateCronSchedulers (schedulerConfig) {
+    for (const config of schedulerConfig) {
+      // Skip disabled schedulers
+      if (config.enabled === false) {
+        continue
       }
-    }
-  }
 
-  async stopApplicationJobs (applicationId) {
-    for (const job of this.jobs.values()) {
-      if (job.applicationId === applicationId) {
-        await this.#stopJob(job)
+      // Validate cron expression
+      const validation = validateCronExpression(config.cron)
+      if (!validation.valid) {
+        throw new Error(`Invalid cron expression "${config.cron}" for scheduler "${config.name}"`)
       }
-    }
-  }
-
-  // Executes a job immediately, regardless of its cron schedule or paused state.
-  // Used by an external coordinator to trigger the execution in this instance.
-  async runJob (name) {
-    const job = this.#getJobOrThrow(name)
-    return this.executeCallback(job)
-  }
 
-  #getJobOrThrow (name) {
-    const job = this.jobs.get(name)
-    if (!job) {
-      throw new SchedulerJobNotFoundError(name)
+      // Set defaults for optional fields
+      const job = {
+        ...config,
+        headers: config.headers || {},
+        body: config.body || {},
+        maxRetries: config.maxRetries || 3
+      }
+      this.jobsConfig.push(job)
     }
-    return job
   }
 
-  #startJob (job) {
-    if (job.cronJob || job.paused) {
-      return
+  start () {
+    for (const job of this.jobsConfig) {
+      this.logger.info(`Configuring scheduler "${job.name}" with cron "${job.cron}"`)
+      const cronJob = CronJob.from({
+        cronTime: job.cron,
+        onTick: async () => {
+          this.logger.info(`Executing scheduler "${job.name}"`)
+          // This cannot throw, the try/catch is inside
+          await this.executeCallback(job)
+        },
+        start: true,
+        timeZone: 'UTC',
+        waitForCompletion: true
+      })
+
+      this.cronJobs.push(cronJob)
     }
-
-    this.logger.info(`Configuring scheduler "${job.name}" with cron "${job.cron}"`)
-    job.cronJob = CronJob.from({
-      cronTime: job.cron,
-      onTick: async () => {
-        this.logger.info(`Executing scheduler "${job.name}"`)
-        // This cannot throw, the try/catch is inside
-        await this.executeCallback(job)
-      },
-      start: true,
-      timeZone: 'UTC',
-      waitForCompletion: true
-    })
   }
 
-  async #stopJob (job) {
-    if (!job.cronJob) {
-      return
+  async stop () {
+    for (const job of this.cronJobs) {
+      await job.stop()
     }
-
-    await job.cronJob.stop()
-    job.cronJob = null
   }
 
   async executeCallback (scheduler) {
     let attempt = 0
     let success = false
-    const scheduledTime = Date.now()
 
     while (!success && attempt < scheduler.maxRetries) {
       try {
@@ -182,32 +74,29 @@ export class SchedulerService {
           )
           await setTimeout(delay)
         }
-        if (scheduler.executor) {
-          await scheduler.executor({ scheduledTime })
-        } else {
-          const headers = {
-            'x-retry-attempt': attempt + 1,
-            ...scheduler.headers
-          }
-
-          const bodyString = typeof scheduler.body === 'string' ? scheduler.body : JSON.stringify(scheduler.body)
-          const response = await request(scheduler.callbackUrl, {
-            method: scheduler.method,
-            headers,
-            body: bodyString,
-            dispatcher: this.dispatcher
-          })
-
-          // Consume the body to release the connection.
-          await response.body.dump()
-
-          if (response.statusCode < 200 || response.statusCode >= 300) {
-            throw new Error(`HTTP error ${response.statusCode}`)
-          }
+        const headers = {
+          'x-retry-attempt': attempt + 1,
+          ...scheduler.headers
         }
 
-        this.logger.info(`Scheduler "${scheduler.name}" executed successfully`)
-        success = true
+        const bodyString = typeof scheduler.body === 'string' ? scheduler.body : JSON.stringify(scheduler.body)
+        const response = await request(scheduler.callbackUrl, {
+          method: scheduler.method,
+          headers,
+          body: bodyString,
+          dispatcher: this.dispatcher
+        })
+
+        // Consumes the body, but we are not interested in the body content,
+        // we don't save it anywere, so we just dump it
+        await response.body.dump()
+
+        if (response.statusCode >= 200 && response.statusCode < 300) {
+          this.logger.info(`Scheduler "${scheduler.name}" executed successfully`)
+          success = true
+        } else {
+          throw new Error(`HTTP error ${response.statusCode}`)
+        }
       } catch (error) {
         this.logger.error(
           `Error executing scheduler "${scheduler.name}" (attempt ${attempt + 1}/${scheduler.maxRetries}):`,
@@ -217,30 +106,9 @@ export class SchedulerService {
       }
     }
 
-    scheduler.lastExecutedAt = new Date().toISOString()
-    scheduler.lastStatus = success ? 'success' : 'failed'
-
     if (!success) {
       this.logger.error(`Scheduler "${scheduler.name}" failed after ${scheduler.maxRetries} attempts`)
     }
-
-    return { name: scheduler.name, success, executedAt: scheduler.lastExecutedAt }
-  }
-
-  #serializeJob (job) {
-    const { cronJob, executor, ...serializable } = job
-    let nextRunAt = null
-
-    if (cronJob) {
-      try {
-        nextRunAt = cronJob.nextDate().toJSDate().toISOString()
-        /* c8 ignore next 3 */
-      } catch {
-        nextRunAt = null
-      }
-    }
-
-    return { ...serializable, nextRunAt }
   }
 }
 

package/lib/worker/controller.js

@@ -95,7 +95,8 @@ export class Controller extends EventEmitter {
       worker: workerData?.worker,
       resourceLimits: workerData?.resourceLimits,
       hasManagementApi: !!runtimeConfig.managementApi,
-      fetchApplicationUrl: fetchApplicationUrl.bind(null, applicationConfig)
+      fetchApplicationUrl: fetchApplicationUrl.bind(null, applicationConfig),
+      strictEnv: runtimeConfig.strictEnv
     }
   }
 
@@ -141,7 +142,8 @@ export class Controller extends EventEmitter {
       if (appConfig.config) {
         // Parse the configuration file the first time to obtain the schema
         const unvalidatedConfig = await loadConfiguration(appConfig.config, null, {
-          onMissingEnv: this.#context.fetchApplicationUrl
+          onMissingEnv: this.#context.fetchApplicationUrl,
+          strictEnv: this.#context.strictEnv
         })
         const pkg = await loadConfigurationModule(appConfig.path, unvalidatedConfig)
         this.capability = await pkg.create(appConfig.path, appConfig.config, this.#context)

package/lib/worker/itc.js

@@ -1,6 +1,6 @@
 import { ensureLoggableError, executeInParallel, executeWithTimeout, kTimeout } from '@platformatic/foundation'
 import { getEvents, getLogger, getMessaging, updateGlobals } from '@platformatic/globals'
-import { initializeITCTelemetry, ITC } from '@platformatic/itc'
+import { ITC, initializeITCTelemetry } from '@platformatic/itc'
 import { Unpromise } from '@watchable/unpromise'
 import { once } from 'node:events'
 import { createRequire } from 'node:module'
@@ -112,9 +112,14 @@ async function safeHandleInITC (worker, fn) {
 }
 
 async function closeITC (dispatcher, itc, messaging) {
-  await dispatcher.interceptor.close()
-  itc.close()
-  messaging.close()
+  try {
+    await dispatcher.interceptor.close()
+    itc.close()
+    messaging.close()
+  } finally {
+    const events = getEvents()
+    events.emit('exit')
+  }
 }
 
 export async function sendViaITC (worker, name, message, transferList) {
@@ -183,7 +188,12 @@ export async function setupITC (controller, application, dispatcher, sharedConte
 
             // Reply to the runtime that the start failed, so it can cleanup
             once(itc, 'application:worker:start:processed').then(() => {
-              closeITC(dispatcher, itc, messaging).catch(() => {})
+              closeITC(dispatcher, itc, messaging).catch(err => {
+                logger.error(
+                  { err: ensureLoggableError(err) },
+                  'Failed to close the worker ITC after a failed start.'
+                )
+              })
             })
 
             throw ensureLoggableError(e)
@@ -195,36 +205,36 @@ export async function setupITC (controller, application, dispatcher, sharedConte
         }
 
         dispatcher.replaceServer(await controller.capability.getDispatchTarget())
-
-        const scheduledTasks =
-          typeof controller.capability.getScheduledTasks === 'function'
-            ? await controller.capability.getScheduledTasks()
-            : []
-
-        return {
-          url: application.entrypoint ? controller.capability.getUrl() : null,
-          scheduledTasks
-        }
+        return application.entrypoint ? controller.capability.getUrl() : null
       },
 
       async stop ({ force, dependents }) {
-        const status = controller.getStatus()
+        try {
+          const status = controller.getStatus()
 
-        if (!force && status === 'starting') {
-          await once(controller, 'start')
-        }
+          if (!force && status === 'starting') {
+            await once(controller, 'start')
+          }
 
-        if (force || status.startsWith('start')) {
-          // This gives a chance to a capability to perform custom logic
-          const events = getEvents()
-          events.emit('stop')
+          if (force || status.startsWith('start')) {
+            // This gives a chance to a capability to perform custom logic
+            const events = getEvents()
+            events.emit('stop')
 
-          await controller.stop(force, dependents)
+            await controller.stop(force, dependents)
+          }
+        } finally {
+          // Always schedule cleanup, even when stop throws. Otherwise the worker
+          // keeps open handles and runtime shutdown hangs until the grace timeout.
+          once(itc, 'application:worker:stop:processed').then(() => {
+            closeITC(dispatcher, itc, messaging).catch(err => {
+              logger.error(
+                { err: ensureLoggableError(err) },
+                'Failed to close the worker ITC after stop.'
+              )
+            })
+          })
         }
-
-        once(itc, 'application:worker:stop:processed').then(() => {
-          closeITC(dispatcher, itc, messaging).catch(() => {})
-        })
       },
 
       async getDependencies () {
@@ -295,22 +305,6 @@ export async function setupITC (controller, application, dispatcher, sharedConte
         }
       },
 
-      async getApplicationScheduledTasks () {
-        if (typeof controller.capability.getScheduledTasks !== 'function') {
-          return []
-        }
-
-        return controller.capability.getScheduledTasks()
-      },
-
-      async runApplicationScheduledTasks ({ scheduleId, scheduledTime }) {
-        if (typeof controller.capability.runScheduledTasks !== 'function') {
-          throw new Error(`Application "${application.id}" does not support scheduled task execution`)
-        }
-
-        return controller.capability.runScheduledTasks(scheduleId, scheduledTime)
-      },
-
       async getApplicationMeta () {
         try {
           return await controller.capability.getMeta()

package/lib/worker/main.js

@@ -364,6 +364,16 @@ async function main () {
 
 function stripBasePath (basePath) {
   const kBasePath = Symbol('kBasePath')
+  const absoluteUrlPattern = /^https?:\/\//i
+
+  function prependBasePath (value) {
+    // Absolute and protocol-relative URLs (RFC 7231 Location) must not be rewritten
+    if (typeof value !== 'string' || absoluteUrlPattern.test(value) || value.startsWith('//') || value.startsWith(basePath)) {
+      return value
+    }
+
+    return basePath + value
+  }
 
   subscribe('http.server.request.start', ({ request, response }) => {
     if (request.url.startsWith(basePath)) {
@@ -389,8 +399,8 @@ function stripBasePath (basePath) {
 
       if (headers) {
         for (const key in headers) {
-          if (key.toLowerCase() === 'location' && !headers[key].startsWith(basePath)) {
-            headers[key] = basePath + headers[key]
+          if (key.toLowerCase() === 'location') {
+            headers[key] = prependBasePath(headers[key])
           }
         }
       }
@@ -401,8 +411,8 @@ function stripBasePath (basePath) {
 
   ServerResponse.prototype.setHeader = function (name, value) {
     if (this[kBasePath]) {
-      if (name.toLowerCase() === 'location' && !value.startsWith(basePath)) {
-        value = basePath + value
+      if (name.toLowerCase() === 'location') {
+        value = prependBasePath(value)
       }
     }
     originSetHeader.call(this, name, value)

package/lib/worker/management.js

@@ -70,22 +70,6 @@ export class ManagementClient {
     return this.#send('getMetrics', { format })
   }
 
-  getScheduler () {
-    return this.#send('getScheduler')
-  }
-
-  pauseSchedulerJob (name) {
-    return this.#send('pauseSchedulerJob', { name })
-  }
-
-  resumeSchedulerJob (name) {
-    return this.#send('resumeSchedulerJob', { name })
-  }
-
-  runSchedulerJob (name) {
-    return this.#send('runSchedulerJob', { name })
-  }
-
   startApplication (id) {
     return this.#send('startApplication', { id })
   }

package/lib/worker/messaging.js

@@ -114,14 +114,21 @@ export class MessagingITC extends ITC {
         context.meta = { ...options?.meta, ...telemetry?.meta }
       }
 
-      const send = () => executeWithTimeout(super.send(name, message, context), this.#timeout)
-      const response = telemetry ? await telemetry.run(send) : await send()
-
-      if (response === kTimeout) {
-        throw new MessagingError(application, 'Timeout while waiting for a response.')
+      const abortController = new AbortController()
+      const timeout = setTimeout(() => abortController.abort(), this.#timeout).unref()
+      context.signal = abortController.signal
+
+      try {
+        const send = () => super.send(name, message, context)
+        return telemetry ? await telemetry.run(send) : await send()
+      } catch (err) {
+        if (abortController.signal.aborted) {
+          throw new MessagingError(application, 'Timeout while waiting for a response.')
+        }
+        throw err
+      } finally {
+        clearTimeout(timeout)
       }
-
-      return response
     } catch (err) {
       error = err
       throw err
@@ -181,6 +188,12 @@ export class MessagingITC extends ITC {
     channel.postMessage(sanitize(request, transferList), transferList)
   }
 
+  _onRequestSettled (reqId, context) {
+    if (context.trackResponse) {
+      context.channel[kPendingResponses].delete(reqId)
+    }
+  }
+
   _createClosePromise () {
     const { promise, resolve, reject } = Promise.withResolvers()
     this.#closeResolvers = { resolve, reject }

package/lib/worker-scaler.js

@@ -121,20 +121,31 @@ export class DynamicWorkersScaler {
 
     if (config.minWorkers > 1) {
       const update = { application: application.id, workers: config.minWorkers }
-
-      if (!this.#status === 'started') {
-        await this.#runtime.updateApplicationsResources([update])
-      } else {
-        this.#initialUpdates.push(update)
-      }
+      this.#initialUpdates.push(update)
     }
 
     this.#appsConfigs[application.id] = config
     this.#algorithm.addApplication(application.id, config)
   }
 
-  remove (application) {
-    this.#algorithm.removeApplication(application.id)
+  async applyPendingUpdate (applicationId) {
+    if (this.#status !== 'started') {
+      return
+    }
+
+    const update = this.#initialUpdates.find(update => update.application === applicationId)
+    if (!update) {
+      return
+    }
+
+    await this.#runtime.updateApplicationsResources([update])
+    this.#initialUpdates = this.#initialUpdates.filter(pending => pending !== update)
+  }
+
+  remove (applicationId) {
+    delete this.#appsConfigs[applicationId]
+    this.#initialUpdates = this.#initialUpdates.filter(update => update.application !== applicationId)
+    this.#algorithm.removeApplication(applicationId)
   }
 
   async #chechHealth () {
@@ -175,7 +186,7 @@ export class DynamicWorkersScaler {
           shouldCheckForScaling = true
         }
       } catch (err) {
-        this.logger.error({ err }, 'Failed to get health for worker')
+        this.#runtime.logger.error({ err }, 'Failed to get health for worker')
       }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.63.0-alpha.3",
+  "version": "3.63.0",
   "description": "Platformatic runtime",
   "main": "index.js",
   "type": "module",
@@ -39,14 +39,14 @@
     "typescript": "^5.9.3",
     "undici-oidc-interceptor": "^0.9.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "3.63.0-alpha.3",
-    "@platformatic/db": "3.63.0-alpha.3",
-    "@platformatic/gateway": "3.63.0-alpha.3",
-    "@platformatic/node": "3.63.0-alpha.3",
-    "@platformatic/service": "3.63.0-alpha.3",
-    "@platformatic/sql-graphql": "3.63.0-alpha.3",
-    "@platformatic/wattpm-pprof-capture": "3.63.0-alpha.3",
-    "@platformatic/sql-mapper": "3.63.0-alpha.3"
+    "@platformatic/composer": "3.63.0",
+    "@platformatic/db": "3.63.0",
+    "@platformatic/gateway": "3.63.0",
+    "@platformatic/service": "3.63.0",
+    "@platformatic/sql-graphql": "3.63.0",
+    "@platformatic/sql-mapper": "3.63.0",
+    "@platformatic/node": "3.63.0",
+    "@platformatic/wattpm-pprof-capture": "3.63.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -69,7 +69,7 @@
     "help-me": "^5.0.0",
     "minimist": "^1.2.8",
     "pino": "^10.1.0",
-    "pino-opentelemetry-transport": "^3.0.0",
+    "pino-opentelemetry-transport": "^4.0.2",
     "pino-pretty": "^13.0.0",
     "semgrator": "^0.3.0",
     "sonic-boom": "^4.2.0",
@@ -77,13 +77,13 @@
     "undici": "^7.27.2",
     "undici-thread-interceptor": "^1.3.1",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.63.0-alpha.3",
-    "@platformatic/foundation": "3.63.0-alpha.3",
-    "@platformatic/generators": "3.63.0-alpha.3",
-    "@platformatic/itc": "3.63.0-alpha.3",
-    "@platformatic/metrics": "3.63.0-alpha.3",
-    "@platformatic/globals": "3.63.0-alpha.3",
-    "@platformatic/telemetry": "3.63.0-alpha.3"
+    "@platformatic/basic": "3.63.0",
+    "@platformatic/generators": "3.63.0",
+    "@platformatic/foundation": "3.63.0",
+    "@platformatic/globals": "3.63.0",
+    "@platformatic/metrics": "3.63.0",
+    "@platformatic/telemetry": "3.63.0",
+    "@platformatic/itc": "3.63.0"
   },
   "engines": {
     "node": ">=22.19.0"