@pipeline-builder/api-core 5.2.8 → 5.2.9

package/lib/services/scheduler.d.ts

@@ -49,6 +49,26 @@ export interface Scheduler {
      */
     stop(): void;
 }
+/**
+ * Liveness gauges every scheduler publishes, labelled `{key}` (the lock key, or
+ * the scheduler's name when it has no lock). Together they let ONE alert rule
+ * cover every job at its own cadence — the interval is published rather than
+ * written into the rule, so a job whose interval an operator overrides through
+ * the environment is judged against the interval it actually runs at.
+ *
+ * - `scheduler_interval_seconds` — the configured interval, set on `start()`.
+ * - `scheduler_started_timestamp_seconds` — when `start()` ran, so a job that
+ *   started but has NEVER succeeded on any pod still has something to age.
+ * - `scheduler_last_success_timestamp_seconds` — the end of the last cycle that
+ *   actually ran the job and returned without throwing. Only the pod that held
+ *   the lock publishes it; a contended or unavailable lock is not a success.
+ *
+ * The values live in process memory, so a restart drops the last success until
+ * the next cycle republishes it. Most jobs run on start, so the gap is minutes.
+ */
+export declare const SCHEDULER_INTERVAL_METRIC = "scheduler_interval_seconds";
+export declare const SCHEDULER_STARTED_METRIC = "scheduler_started_timestamp_seconds";
+export declare const SCHEDULER_LAST_SUCCESS_METRIC = "scheduler_last_success_timestamp_seconds";
 /**
  * A periodic background job: a single unref'd `setInterval` with start-once
  * semantics, error isolation (a throwing cycle is logged, never crashes the

package/lib/services/scheduler.js

@@ -2,7 +2,28 @@
 // SPDX-License-Identifier: Apache-2.0
 import { acquireSharedEnvLock, releaseSharedEnvLock, withLeaderLock } from './leader-lock.js';
 import { createLogger } from '../utils/logger.js';
+import { emitGauge } from '../utils/metric-emitter.js';
 import { errorMessage } from '../utils/response.js';
+/**
+ * Liveness gauges every scheduler publishes, labelled `{key}` (the lock key, or
+ * the scheduler's name when it has no lock). Together they let ONE alert rule
+ * cover every job at its own cadence — the interval is published rather than
+ * written into the rule, so a job whose interval an operator overrides through
+ * the environment is judged against the interval it actually runs at.
+ *
+ * - `scheduler_interval_seconds` — the configured interval, set on `start()`.
+ * - `scheduler_started_timestamp_seconds` — when `start()` ran, so a job that
+ *   started but has NEVER succeeded on any pod still has something to age.
+ * - `scheduler_last_success_timestamp_seconds` — the end of the last cycle that
+ *   actually ran the job and returned without throwing. Only the pod that held
+ *   the lock publishes it; a contended or unavailable lock is not a success.
+ *
+ * The values live in process memory, so a restart drops the last success until
+ * the next cycle republishes it. Most jobs run on start, so the gap is minutes.
+ */
+export const SCHEDULER_INTERVAL_METRIC = 'scheduler_interval_seconds';
+export const SCHEDULER_STARTED_METRIC = 'scheduler_started_timestamp_seconds';
+export const SCHEDULER_LAST_SUCCESS_METRIC = 'scheduler_last_success_timestamp_seconds';
 /**
  * A periodic background job: a single unref'd `setInterval` with start-once
  * semantics, error isolation (a throwing cycle is logged, never crashes the
@@ -14,6 +35,7 @@ import { errorMessage } from '../utils/response.js';
  */
 export function createScheduler(opts) {
     const log = createLogger(opts.name);
+    const metricLabels = { key: opts.lock?.key ?? opts.name };
     let interval = null;
     let startup = null;
     let stopped = false;
@@ -25,6 +47,10 @@ export function createScheduler(opts) {
     let shutdown = new AbortController();
     /** The in-flight cycle, so `stop()` can wait for it before closing the client. */
     let inFlight = null;
+    /** A cycle that was cut short by `stop()` is not stamped: it did not finish. */
+    const stampSuccess = () => {
+        emitGauge(SCHEDULER_LAST_SUCCESS_METRIC, metricLabels, Date.now() / 1000);
+    };
     const cycle = async () => {
         // Same-pod re-entrancy guard: setInterval doesn't await the async cycle, so
         // a cycle slower than intervalMs would otherwise overlap ITSELF on this pod
@@ -45,11 +71,15 @@ export function createScheduler(opts) {
                 const ran = await withLeaderLock(redis, opts.lock.key, opts.lock.ttlMs, opts.run, { signal });
                 if (!ran)
                     log.debug('Cycle skipped — another pod holds the lock');
+                else if (!signal.aborted)
+                    stampSuccess();
             }
             else {
                 // Unlocked: still give the job a signal, so `stop()` can cut a long cycle
                 // short rather than waiting for it during shutdown.
                 await opts.run({ signal });
+                if (!signal.aborted)
+                    stampSuccess();
             }
         }
         catch (err) {
@@ -82,6 +112,8 @@ export function createScheduler(opts) {
             // one, and an already-aborted signal would make every cycle a no-op.
             if (shutdown.signal.aborted)
                 shutdown = new AbortController();
+            emitGauge(SCHEDULER_INTERVAL_METRIC, metricLabels, opts.intervalMs / 1000);
+            emitGauge(SCHEDULER_STARTED_METRIC, metricLabels, Date.now() / 1000);
             if (opts.lock && !opts.lock.redis && !holdsEnvLock) {
                 envLock = acquireSharedEnvLock();
                 holdsEnvLock = true;
@@ -125,4 +157,4 @@ export function createScheduler(opts) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scheduler.js","sources":["../../src/services/scheduler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { acquireSharedEnvLock, releaseSharedEnvLock, withLeaderLock, type LeaderLockRun, type LockRedis } from './leader-lock.js';\nimport { createLogger } from '../utils/logger.js';\nimport { errorMessage } from '../utils/response.js';\n\n/**\n * Optional cross-pod single-runner lock for a scheduler's cycle. Without\n * `redis` the scheduler uses the process's shared env-configured lock client\n * (taken on `start`, released on `stop`); when Redis isn't configured the cycle\n * runs on every pod, so the work it wraps must stay safe to run concurrently.\n * A supplied `redis` factory is resolved per cycle (e.g. a BullMQ connection).\n */\nexport interface SchedulerLock {\n  key: string;\n  ttlMs: number;\n  redis?: () => LockRedis;\n}\n\nexport interface SchedulerOptions {\n  /** Log label (also the logger name). */\n  name: string;\n  /** Interval between cycles (ms). */\n  intervalMs: number;\n  /**\n   * The work to run each cycle. Errors are caught + logged, never thrown.\n   *\n   * `run.signal` is aborted when a leader-locked cycle LOSES its lock mid-run, or\n   * when `stop()` is called. A job that iterates over units of work (orgs, repos,\n   * entities) must check it between units and return: past a lock loss another pod\n   * may be doing the same work, and on shutdown returning promptly is what\n   * releases the lock instead of leaving it to expire. Unlocked schedulers get a\n   * signal too — it fires on `stop()` only.\n   */\n  run: (run: LeaderLockRun) => Promise<void>;\n  /** Run a cycle immediately when started. Default true. */\n  runOnStart?: boolean;\n  /** Delay before the first cycle (and before the interval begins), ms.\n   *  Default 0. Lets a service wait for dependencies to come up. */\n  startupDelayMs?: number;\n  /** When set, each cycle runs only on the pod that wins this lock — so with\n   *  multiple replicas only one runs per window. */\n  lock?: SchedulerLock;\n}\n\nexport interface Scheduler {\n  /** Start the timer. Idempotent — repeated calls are no-ops. */\n  start(): void;\n  /**\n   * Stop the timer (and cancel a pending startup delay). Safe before start.\n   *\n   * Also ABORTS an in-flight cycle's `run.signal` and defers closing the shared\n   * lock client until that cycle settles: a running cycle used to keep its lock\n   * key until the TTL lapsed, so a rolling deploy mid-run parked the job for the\n   * rest of the TTL. A signal-aware `run` returns and the lock is released.\n   */\n  stop(): void;\n}\n\n/**\n * A periodic background job: a single unref'd `setInterval` with start-once\n * semantics, error isolation (a throwing cycle is logged, never crashes the\n * loop), an optional startup delay, and an optional cross-pod leader lock.\n *\n * Replaces the hand-rolled timer/`unref`/`catch`/start-stop boilerplate that\n * each scheduler (scan, digest, registry GC, billing lifecycle) repeated, and\n * makes the leader lock available to all of them uniformly.\n */\nexport function createScheduler(opts: SchedulerOptions): Scheduler {\n  const log = createLogger(opts.name);\n  let interval: ReturnType<typeof setInterval> | null = null;\n  let startup: ReturnType<typeof setTimeout> | null = null;\n  let stopped = false;\n  let running = false;\n  /** The shared env client this scheduler holds a reference on (own-client locks don't). */\n  let envLock: LockRedis | null = null;\n  let holdsEnvLock = false;\n  /** Aborted by `stop()`, so an in-flight cycle can return and release its lock. */\n  let shutdown = new AbortController();\n  /** The in-flight cycle, so `stop()` can wait for it before closing the client. */\n  let inFlight: Promise<void> | null = null;\n\n  const cycle = async (): Promise<void> => {\n    // Same-pod re-entrancy guard: setInterval doesn't await the async cycle, so\n    // a cycle slower than intervalMs would otherwise overlap ITSELF on this pod\n    // (double-processing, duplicate side effects). The optional leader lock only\n    // guards CROSS-pod overlap; this guards same-pod. A skipped tick just runs on\n    // the next interval.\n    if (running) {\n      log.debug('Cycle skipped — previous cycle still running (same-pod re-entrancy)');\n      return;\n    }\n    running = true;\n    const signal = shutdown.signal;\n    try {\n      const redis = opts.lock ? (opts.lock.redis ? opts.lock.redis() : envLock) : null;\n      if (opts.lock && redis) {\n        // withLeaderLock merges `signal` into the run's own, so `run` sees a single\n        // signal for both \"lock lost\" and \"shutting down\".\n        const ran = await withLeaderLock(redis, opts.lock.key, opts.lock.ttlMs, opts.run, { signal });\n        if (!ran) log.debug('Cycle skipped — another pod holds the lock');\n      } else {\n        // Unlocked: still give the job a signal, so `stop()` can cut a long cycle\n        // short rather than waiting for it during shutdown.\n        await opts.run({ signal });\n      }\n    } catch (err) {\n      log.error('Scheduler cycle failed', { error: errorMessage(err) });\n    } finally {\n      running = false;\n    }\n  };\n\n  /** Run a cycle and publish it as `inFlight` so `stop()` can await it. */\n  const runCycle = (): void => {\n    const p = cycle().finally(() => { if (inFlight === p) inFlight = null; });\n    inFlight = p;\n  };\n\n  const begin = (): void => {\n    if (stopped) return; // stop() called during the startup delay\n    if (opts.runOnStart !== false) runCycle();\n    interval = setInterval(() => runCycle(), opts.intervalMs);\n    interval.unref();\n  };\n\n  return {\n    start(): void {\n      if (interval || startup) return;\n      stopped = false;\n      // A restart needs a fresh controller: the previous stop() aborted the old\n      // one, and an already-aborted signal would make every cycle a no-op.\n      if (shutdown.signal.aborted) shutdown = new AbortController();\n      if (opts.lock && !opts.lock.redis && !holdsEnvLock) {\n        envLock = acquireSharedEnvLock();\n        holdsEnvLock = true;\n      }\n      if (opts.startupDelayMs && opts.startupDelayMs > 0) {\n        startup = setTimeout(() => { startup = null; begin(); }, opts.startupDelayMs);\n        startup.unref();\n      } else {\n        begin();\n      }\n      log.info('Scheduler started', { intervalMs: opts.intervalMs, locked: !!opts.lock && (!!opts.lock.redis || !!envLock) });\n    },\n    stop(): void {\n      stopped = true;\n      if (startup) { clearTimeout(startup); startup = null; }\n      if (interval) { clearInterval(interval); interval = null; }\n      // Ask an in-flight cycle to wind up. A signal-aware `run` returns between\n      // units of work, which lets withLeaderLock's `finally` RELEASE the lock —\n      // otherwise the key sat there until the TTL lapsed and the job was parked\n      // fleet-wide for that long after every rolling deploy.\n      if (!shutdown.signal.aborted) shutdown.abort('shutdown');\n      if (holdsEnvLock) {\n        holdsEnvLock = false;\n        const pending = inFlight;\n        envLock = null;\n        // Closing the client under a running cycle kills its heartbeat and its\n        // release, so wait for the cycle to settle first. Bounded by the cycle\n        // itself, which is now being asked to stop.\n        void (pending ? pending.catch(() => undefined) : Promise.resolve())\n          .then(() => releaseSharedEnvLock());\n      }\n      log.info('Scheduler stopped');\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scheduler.js","sources":["../../src/services/scheduler.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { acquireSharedEnvLock, releaseSharedEnvLock, withLeaderLock, type LeaderLockRun, type LockRedis } from './leader-lock.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitGauge } from '../utils/metric-emitter.js';\nimport { errorMessage } from '../utils/response.js';\n\n/**\n * Optional cross-pod single-runner lock for a scheduler's cycle. Without\n * `redis` the scheduler uses the process's shared env-configured lock client\n * (taken on `start`, released on `stop`); when Redis isn't configured the cycle\n * runs on every pod, so the work it wraps must stay safe to run concurrently.\n * A supplied `redis` factory is resolved per cycle (e.g. a BullMQ connection).\n */\nexport interface SchedulerLock {\n  key: string;\n  ttlMs: number;\n  redis?: () => LockRedis;\n}\n\nexport interface SchedulerOptions {\n  /** Log label (also the logger name). */\n  name: string;\n  /** Interval between cycles (ms). */\n  intervalMs: number;\n  /**\n   * The work to run each cycle. Errors are caught + logged, never thrown.\n   *\n   * `run.signal` is aborted when a leader-locked cycle LOSES its lock mid-run, or\n   * when `stop()` is called. A job that iterates over units of work (orgs, repos,\n   * entities) must check it between units and return: past a lock loss another pod\n   * may be doing the same work, and on shutdown returning promptly is what\n   * releases the lock instead of leaving it to expire. Unlocked schedulers get a\n   * signal too — it fires on `stop()` only.\n   */\n  run: (run: LeaderLockRun) => Promise<void>;\n  /** Run a cycle immediately when started. Default true. */\n  runOnStart?: boolean;\n  /** Delay before the first cycle (and before the interval begins), ms.\n   *  Default 0. Lets a service wait for dependencies to come up. */\n  startupDelayMs?: number;\n  /** When set, each cycle runs only on the pod that wins this lock — so with\n   *  multiple replicas only one runs per window. */\n  lock?: SchedulerLock;\n}\n\nexport interface Scheduler {\n  /** Start the timer. Idempotent — repeated calls are no-ops. */\n  start(): void;\n  /**\n   * Stop the timer (and cancel a pending startup delay). Safe before start.\n   *\n   * Also ABORTS an in-flight cycle's `run.signal` and defers closing the shared\n   * lock client until that cycle settles: a running cycle used to keep its lock\n   * key until the TTL lapsed, so a rolling deploy mid-run parked the job for the\n   * rest of the TTL. A signal-aware `run` returns and the lock is released.\n   */\n  stop(): void;\n}\n\n/**\n * Liveness gauges every scheduler publishes, labelled `{key}` (the lock key, or\n * the scheduler's name when it has no lock). Together they let ONE alert rule\n * cover every job at its own cadence — the interval is published rather than\n * written into the rule, so a job whose interval an operator overrides through\n * the environment is judged against the interval it actually runs at.\n *\n * - `scheduler_interval_seconds` — the configured interval, set on `start()`.\n * - `scheduler_started_timestamp_seconds` — when `start()` ran, so a job that\n *   started but has NEVER succeeded on any pod still has something to age.\n * - `scheduler_last_success_timestamp_seconds` — the end of the last cycle that\n *   actually ran the job and returned without throwing. Only the pod that held\n *   the lock publishes it; a contended or unavailable lock is not a success.\n *\n * The values live in process memory, so a restart drops the last success until\n * the next cycle republishes it. Most jobs run on start, so the gap is minutes.\n */\nexport const SCHEDULER_INTERVAL_METRIC = 'scheduler_interval_seconds';\nexport const SCHEDULER_STARTED_METRIC = 'scheduler_started_timestamp_seconds';\nexport const SCHEDULER_LAST_SUCCESS_METRIC = 'scheduler_last_success_timestamp_seconds';\n\n/**\n * A periodic background job: a single unref'd `setInterval` with start-once\n * semantics, error isolation (a throwing cycle is logged, never crashes the\n * loop), an optional startup delay, and an optional cross-pod leader lock.\n *\n * Replaces the hand-rolled timer/`unref`/`catch`/start-stop boilerplate that\n * each scheduler (scan, digest, registry GC, billing lifecycle) repeated, and\n * makes the leader lock available to all of them uniformly.\n */\nexport function createScheduler(opts: SchedulerOptions): Scheduler {\n  const log = createLogger(opts.name);\n  const metricLabels = { key: opts.lock?.key ?? opts.name };\n  let interval: ReturnType<typeof setInterval> | null = null;\n  let startup: ReturnType<typeof setTimeout> | null = null;\n  let stopped = false;\n  let running = false;\n  /** The shared env client this scheduler holds a reference on (own-client locks don't). */\n  let envLock: LockRedis | null = null;\n  let holdsEnvLock = false;\n  /** Aborted by `stop()`, so an in-flight cycle can return and release its lock. */\n  let shutdown = new AbortController();\n  /** The in-flight cycle, so `stop()` can wait for it before closing the client. */\n  let inFlight: Promise<void> | null = null;\n\n  /** A cycle that was cut short by `stop()` is not stamped: it did not finish. */\n  const stampSuccess = (): void => {\n    emitGauge(SCHEDULER_LAST_SUCCESS_METRIC, metricLabels, Date.now() / 1000);\n  };\n\n  const cycle = async (): Promise<void> => {\n    // Same-pod re-entrancy guard: setInterval doesn't await the async cycle, so\n    // a cycle slower than intervalMs would otherwise overlap ITSELF on this pod\n    // (double-processing, duplicate side effects). The optional leader lock only\n    // guards CROSS-pod overlap; this guards same-pod. A skipped tick just runs on\n    // the next interval.\n    if (running) {\n      log.debug('Cycle skipped — previous cycle still running (same-pod re-entrancy)');\n      return;\n    }\n    running = true;\n    const signal = shutdown.signal;\n    try {\n      const redis = opts.lock ? (opts.lock.redis ? opts.lock.redis() : envLock) : null;\n      if (opts.lock && redis) {\n        // withLeaderLock merges `signal` into the run's own, so `run` sees a single\n        // signal for both \"lock lost\" and \"shutting down\".\n        const ran = await withLeaderLock(redis, opts.lock.key, opts.lock.ttlMs, opts.run, { signal });\n        if (!ran) log.debug('Cycle skipped — another pod holds the lock');\n        else if (!signal.aborted) stampSuccess();\n      } else {\n        // Unlocked: still give the job a signal, so `stop()` can cut a long cycle\n        // short rather than waiting for it during shutdown.\n        await opts.run({ signal });\n        if (!signal.aborted) stampSuccess();\n      }\n    } catch (err) {\n      log.error('Scheduler cycle failed', { error: errorMessage(err) });\n    } finally {\n      running = false;\n    }\n  };\n\n  /** Run a cycle and publish it as `inFlight` so `stop()` can await it. */\n  const runCycle = (): void => {\n    const p = cycle().finally(() => { if (inFlight === p) inFlight = null; });\n    inFlight = p;\n  };\n\n  const begin = (): void => {\n    if (stopped) return; // stop() called during the startup delay\n    if (opts.runOnStart !== false) runCycle();\n    interval = setInterval(() => runCycle(), opts.intervalMs);\n    interval.unref();\n  };\n\n  return {\n    start(): void {\n      if (interval || startup) return;\n      stopped = false;\n      // A restart needs a fresh controller: the previous stop() aborted the old\n      // one, and an already-aborted signal would make every cycle a no-op.\n      if (shutdown.signal.aborted) shutdown = new AbortController();\n      emitGauge(SCHEDULER_INTERVAL_METRIC, metricLabels, opts.intervalMs / 1000);\n      emitGauge(SCHEDULER_STARTED_METRIC, metricLabels, Date.now() / 1000);\n      if (opts.lock && !opts.lock.redis && !holdsEnvLock) {\n        envLock = acquireSharedEnvLock();\n        holdsEnvLock = true;\n      }\n      if (opts.startupDelayMs && opts.startupDelayMs > 0) {\n        startup = setTimeout(() => { startup = null; begin(); }, opts.startupDelayMs);\n        startup.unref();\n      } else {\n        begin();\n      }\n      log.info('Scheduler started', { intervalMs: opts.intervalMs, locked: !!opts.lock && (!!opts.lock.redis || !!envLock) });\n    },\n    stop(): void {\n      stopped = true;\n      if (startup) { clearTimeout(startup); startup = null; }\n      if (interval) { clearInterval(interval); interval = null; }\n      // Ask an in-flight cycle to wind up. A signal-aware `run` returns between\n      // units of work, which lets withLeaderLock's `finally` RELEASE the lock —\n      // otherwise the key sat there until the TTL lapsed and the job was parked\n      // fleet-wide for that long after every rolling deploy.\n      if (!shutdown.signal.aborted) shutdown.abort('shutdown');\n      if (holdsEnvLock) {\n        holdsEnvLock = false;\n        const pending = inFlight;\n        envLock = null;\n        // Closing the client under a running cycle kills its heartbeat and its\n        // release, so wait for the cycle to settle first. Bounded by the cycle\n        // itself, which is now being asked to stop.\n        void (pending ? pending.catch(() => undefined) : Promise.resolve())\n          .then(() => releaseSharedEnvLock());\n      }\n      log.info('Scheduler stopped');\n    },\n  };\n}\n"]}

package/package.json

@@ -127,7 +127,7 @@
       ]
     }
   },
-  "version": "5.2.8",
+  "version": "5.2.9",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },