pg-boss 12.35.1 → 12.37.0

package/dist/migrationStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migrationStore.d.ts","sourceRoot":"","sources":["../src/migrationStore.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAKnC,UAAU,cAAc;IACtB,WAAW,CAAC,EAAE,OAAO,CAAA;IAKrB,eAAe,CAAC,EAAE,KAAK,CAAC,kBAAkB,EAAE,CAAA;CAC7C;AAoGD,UAAU,iBAAiB;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AASD,iBAAS,QAAQ,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,EAAE,eAAe,CAAC,EAAE,OAAO,UAsB5G;AAED,iBAAS,IAAI,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,EAAE,eAAe,CAAC,EAAE,OAAO,UAQxG;AAKD,iBAAS,eAAe,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,EAAE,eAAe,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,cAAmB,GAAG,iBAAiB,CAiDrK;AAKD,iBAAS,OAAO,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,EAAE,eAAe,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,cAAmB,UAIzI;AAgoCD,iBAAS,aAAa,CAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE9C;AAID,iBAAS,eAAe,CAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,0BAA0B,EAAE,QAAQ,GAAG,qBAAqB,GAAG,mBAAmB,GAAG,qBAAqB,CAAC,GAAG,KAAK,CAAC,SAAS,EAAE,CAE3K;AAOD,iBAAS,MAAM,CAAE,MAAM,EAAE,MAAM,EAAE,cAAc,UAAQ,EAAE,UAAU,UAAQ,EAAE,mBAAmB,UAAQ,GAAG,KAAK,CAAC,SAAS,EAAE,CA4oB3H;AAED,OAAO,EACL,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,eAAe,EACf,MAAM,EACN,eAAe,EACf,aAAa,GACd,CAAA"}
+{"version":3,"file":"migrationStore.d.ts","sourceRoot":"","sources":["../src/migrationStore.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAKnC,UAAU,cAAc;IACtB,WAAW,CAAC,EAAE,OAAO,CAAA;IAKrB,eAAe,CAAC,EAAE,KAAK,CAAC,kBAAkB,EAAE,CAAA;CAC7C;AAoGD,UAAU,iBAAiB;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AASD,iBAAS,QAAQ,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,EAAE,eAAe,CAAC,EAAE,OAAO,UAsB5G;AAED,iBAAS,IAAI,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,EAAE,eAAe,CAAC,EAAE,OAAO,UAQxG;AAKD,iBAAS,eAAe,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,EAAE,eAAe,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,cAAmB,GAAG,iBAAiB,CAiDrK;AAKD,iBAAS,OAAO,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,EAAE,eAAe,CAAC,EAAE,OAAO,EAAE,OAAO,GAAE,cAAmB,UAIzI;AA6tCD,iBAAS,aAAa,CAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE9C;AAID,iBAAS,eAAe,CAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,0BAA0B,EAAE,QAAQ,GAAG,qBAAqB,GAAG,mBAAmB,GAAG,qBAAqB,CAAC,GAAG,KAAK,CAAC,SAAS,EAAE,CAE3K;AAOD,iBAAS,MAAM,CAAE,MAAM,EAAE,MAAM,EAAE,cAAc,UAAQ,EAAE,UAAU,UAAQ,EAAE,mBAAmB,UAAQ,GAAG,KAAK,CAAC,SAAS,EAAE,CAivB3H;AAED,OAAO,EACL,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,eAAe,EACf,MAAM,EACN,eAAe,EACf,aAAa,GACd,CAAA"}

package/dist/migrationStore.js

@@ -1087,6 +1087,99 @@ const createQueueFn = {
     EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
     END IF;
 
+    EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
+    EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
+    END;
+    $$
+    LANGUAGE plpgsql;
+  `,
+    45: (schema) => `
+    CREATE OR REPLACE FUNCTION ${schema}.create_queue(queue_name text, options jsonb)
+    RETURNS VOID AS
+    $$
+    DECLARE
+    tablename varchar := CASE WHEN options->>'partition' = 'true'
+    THEN 'j' || encode(sha224(queue_name::bytea), 'hex')
+    ELSE 'job_common'
+    END;
+    queue_created_on timestamptz;
+    BEGIN
+
+    WITH q as (
+    INSERT INTO ${schema}.queue (
+    name,
+    policy,
+    retry_limit,
+    retry_delay,
+    retry_backoff,
+    retry_delay_max,
+    expire_seconds,
+    retention_seconds,
+    deletion_seconds,
+    warning_queued,
+    dead_letter,
+    partition,
+    table_name,
+    heartbeat_seconds,
+    notify,
+    created_on,
+    updated_on
+    )
+    VALUES (
+    queue_name,
+    options->>'policy',
+    COALESCE((options->>'retryLimit')::int, 2),
+    COALESCE((options->>'retryDelay')::int, 0),
+    COALESCE((options->>'retryBackoff')::bool, false),
+    (options->>'retryDelayMax')::int,
+    COALESCE((options->>'expireInSeconds')::int, 900),
+    COALESCE((options->>'retentionSeconds')::int, 1209600),
+    COALESCE((options->>'deleteAfterSeconds')::int, 604800),
+    COALESCE((options->>'warningQueueSize')::int, 0),
+    options->>'deadLetter',
+    COALESCE((options->>'partition')::bool, false),
+    tablename,
+    (options->>'heartbeatSeconds')::int,
+    COALESCE((options->>'notify')::bool, false),
+    ${schema}.job_now(),
+    ${schema}.job_now()
+    )
+    ON CONFLICT DO NOTHING
+    RETURNING created_on
+    )
+    SELECT created_on into queue_created_on from q;
+
+    IF queue_created_on IS NULL OR options->>'partition' IS DISTINCT FROM 'true' THEN
+    RETURN;
+    END IF;
+
+    EXECUTE format('CREATE TABLE ${schema}.%I (LIKE ${schema}.job INCLUDING DEFAULTS)', tablename);
+
+    EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD PRIMARY KEY (name, id)$cmd$, tablename);
+    EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT q_fkey FOREIGN KEY (name) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+    EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT dlq_fkey FOREIGN KEY (dead_letter) REFERENCES ${schema}.queue (name) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED$cmd$, tablename);
+
+    EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i11 ON ${schema}.job (name, priority DESC, created_on, start_after) WHERE state < 'active' AND NOT blocked$cmd$, tablename);
+    EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i4 ON ${schema}.job (name, singleton_on, COALESCE(singleton_key, '')) WHERE state <> 'cancelled' AND singleton_on IS NOT NULL$cmd$, tablename);
+    EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i7 ON ${schema}.job (name, group_id) WHERE state = 'active' AND group_id IS NOT NULL$cmd$, tablename);
+    EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i9 ON ${schema}.job (name, id) WHERE blocking AND state = 'completed'$cmd$, tablename);
+    EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i12 ON ${schema}.job (source_root_id) WHERE source_root_id IS NOT NULL$cmd$, tablename);
+    EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i13 ON ${schema}.job (name, singleton_key) WHERE state = 'created' AND upsert_by_key$cmd$, tablename);
+
+    IF options->>'policy' = 'short' THEN
+    EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i1 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'created' AND policy = 'short'$cmd$, tablename);
+    ELSIF options->>'policy' = 'singleton' THEN
+    EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i2 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state = 'active' AND policy = 'singleton'$cmd$, tablename);
+    ELSIF options->>'policy' = 'stately' THEN
+    EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i3 ON ${schema}.job (name, state, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'stately'$cmd$, tablename);
+    ELSIF options->>'policy' = 'exclusive' THEN
+    EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i6 ON ${schema}.job (name, COALESCE(singleton_key, '')) WHERE state <= 'active' AND policy = 'exclusive'$cmd$, tablename);
+    ELSIF options->>'policy' = 'key_strict_fifo' THEN
+    EXECUTE ${schema}.job_table_format($cmd$CREATE UNIQUE INDEX job_i8 ON ${schema}.job (name, singleton_key) WHERE state IN ('active', 'retry', 'failed') AND policy = 'key_strict_fifo'$cmd$, tablename);
+    EXECUTE ${schema}.job_table_format($cmd$CREATE INDEX job_i10 ON ${schema}.job (name, singleton_key, state DESC, created_on, id) INCLUDE (start_after) WHERE state < 'active' AND NOT blocked AND policy = 'key_strict_fifo'$cmd$, tablename);
+    EXECUTE ${schema}.job_table_format($cmd$ALTER TABLE ${schema}.job ADD CONSTRAINT job_key_strict_fifo_singleton_key_check CHECK (NOT (policy = 'key_strict_fifo' AND singleton_key IS NULL))$cmd$, tablename);
+    END IF;
+
     EXECUTE format('ALTER TABLE ${schema}.%I ADD CONSTRAINT cjc CHECK (name=%L)', tablename, queue_name);
     EXECUTE format('ALTER TABLE ${schema}.job ATTACH PARTITION ${schema}.%I FOR VALUES IN (%L)', tablename, queue_name);
     END;
@@ -1963,6 +2056,107 @@ AS $function$
           DROP COLUMN source_output,
           DROP COLUMN source_root_id`
             ]
+        },
+        {
+            release: '12.36.0',
+            version: 44,
+            previous: 43,
+            // The instance table starts empty: each instance registers on its next start().
+            // blocked_count's constant default adds it without a table rewrite, and existing queues read 0
+            // until the next monitor pass counts them. It goes on the queue row only, not queue_stats, so
+            // the covering index on queue_stats needs no rebuild.
+            // The histogram and ready_oldest_seconds columns are nullable with no default, like the v43
+            // deltas, so no statement rewrites a table, and a snapshot captured before them reads as not
+            // counted rather than as a queue with no waits.
+            // trace_context is nullable with no default too, so adding it rewrites no rows.
+            install: [
+                /* eslint-disable no-restricted-syntax -- column defaults stay on the real clock: every pg-boss write names its timestamps through job_now() */
+                `CREATE TABLE ${schema}.instance (
+          id uuid PRIMARY KEY,
+          name text,
+          host text NOT NULL,
+          pid int NOT NULL,
+          version text NOT NULL,
+          node_version text NOT NULL,
+          application_name text,
+          heartbeat_seconds int NOT NULL,
+          supervise bool NOT NULL,
+          schedule bool NOT NULL,
+          migrate bool NOT NULL,
+          persist_queue_stats bool NOT NULL,
+          persist_warnings bool NOT NULL,
+          pool_max int,
+          pool_total int,
+          pool_idle int,
+          pool_waiting int,
+          workers jsonb NOT NULL DEFAULT '[]'::jsonb,
+          metrics jsonb,
+          config jsonb NOT NULL DEFAULT '{}'::jsonb,
+          crash_restarts int NOT NULL DEFAULT 0,
+          crash_restarts_since timestamptz,
+          started_on timestamptz NOT NULL DEFAULT now(),
+          heartbeat_on timestamptz NOT NULL DEFAULT now(),
+          stopped_on timestamptz
+        )`,
+                /* eslint-enable no-restricted-syntax */
+                `ALTER TABLE ${schema}.queue
+          ADD COLUMN blocked_count int NOT NULL DEFAULT 0,
+          ADD COLUMN wait_bins int[],
+          ADD COLUMN run_bins int[],
+          ADD COLUMN ready_oldest_seconds int`,
+                `ALTER TABLE ${schema}.queue_stats
+          ADD COLUMN wait_bins int[],
+          ADD COLUMN run_bins int[],
+          ADD COLUMN ready_oldest_seconds int`,
+                `ALTER TABLE ${schema}.job ADD COLUMN IF NOT EXISTS trace_context jsonb`
+            ],
+            uninstall: [
+                `DROP TABLE ${schema}.instance`,
+                `ALTER TABLE ${schema}.queue
+          DROP COLUMN blocked_count,
+          DROP COLUMN wait_bins,
+          DROP COLUMN run_bins,
+          DROP COLUMN ready_oldest_seconds`,
+                `ALTER TABLE ${schema}.queue_stats
+          DROP COLUMN wait_bins,
+          DROP COLUMN run_bins,
+          DROP COLUMN ready_oldest_seconds`,
+                `ALTER TABLE ${schema}.job DROP COLUMN trace_context`
+            ]
+        },
+        {
+            release: '12.37.0',
+            version: 45,
+            previous: 44,
+            // upsert_by_key is nullable with no default, so adding it rewrites no rows, and no existing job
+            // carries it. job_i13 therefore starts empty and cannot fail on existing duplicates.
+            // It is built the way v43 built job_i12: inline without partitioning, otherwise through
+            // create_queue for new partitions and BAM, concurrently, for the tables that already exist.
+            install: [
+                `ALTER TABLE ${schema}.job ADD COLUMN IF NOT EXISTS upsert_by_key bool`,
+                noPartitioning
+                    ? `CREATE UNIQUE INDEX job_i13 ON ${schema}.job (name, singleton_key) WHERE state = 'created' AND upsert_by_key`
+                    : createQueueFn[45](schema)
+            ],
+            async: noPartitioning
+                ? []
+                : [
+                    {
+                        name: 'upsert_index_build',
+                        command: `CREATE UNIQUE INDEX CONCURRENTLY IF NOT EXISTS job_i13 ON ${schema}.job (name, singleton_key) WHERE state = 'created' AND upsert_by_key`
+                    }
+                ],
+            // The index goes before its column, and create_queue is restored first, as in v43. CASCADE because
+            // CockroachDB will not drop a unique index without it.
+            uninstall: [
+                ...(noPartitioning
+                    ? [`DROP INDEX IF EXISTS ${schema}.job_i13 CASCADE`]
+                    : [
+                        createQueueFn[43](schema),
+                        `SELECT ${schema}.job_table_run($cmd$DROP INDEX IF EXISTS ${schema}.job_i13$cmd$)`
+                    ]),
+                `ALTER TABLE ${schema}.job DROP COLUMN upsert_by_key`
+            ]
         }
     ];
 }

package/dist/nurse.d.ts

@@ -0,0 +1,20 @@
+import type * as types from './types.ts';
+interface Hierarchy {
+    dirs: string[];
+}
+export interface Cgroup {
+    version: 1 | 2;
+    cpu: Hierarchy | null;
+    memory: Hierarchy | null;
+}
+export declare function findCgroup(prefix?: string): Promise<Cgroup | null>;
+export declare function countCpuList(list: string): number | null;
+declare class Nurse {
+    #private;
+    constructor(prefix?: string);
+    start(): void;
+    stop(): void;
+    check(): Promise<types.InstanceMetrics>;
+}
+export default Nurse;
+//# sourceMappingURL=nurse.d.ts.map

package/dist/nurse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nurse.d.ts","sourceRoot":"","sources":["../src/nurse.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AAmBxC,UAAU,SAAS;IAGjB,IAAI,EAAE,MAAM,EAAE,CAAA;CACf;AAED,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,CAAC,GAAG,CAAC,CAAA;IACd,GAAG,EAAE,SAAS,GAAG,IAAI,CAAA;IACrB,MAAM,EAAE,SAAS,GAAG,IAAI,CAAA;CACzB;AAmDD,wBAAsB,UAAU,CAAE,MAAM,SAAK,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkDrE;AA0ED,wBAAgB,YAAY,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUzD;AAYD,cAAM,KAAK;;gBASI,MAAM,SAAK;IAIxB,KAAK;IAgBL,IAAI;IAOE,KAAK,IAAK,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC;CAmF/C;AAED,eAAe,KAAK,CAAA"}

package/dist/nurse.js

@@ -0,0 +1,287 @@
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import { monitorEventLoopDelay, performance } from 'node:perf_hooks';
+import v8 from 'node:v8';
+// Takes this process's vitals on each registry heartbeat: what it is using and what it is allowed. Inside a
+// container the host-wide figures Node offers are the wrong ones: os.totalmem(), os.freemem(),
+// os.loadavg() and os.cpus() describe the machine, not the container, and os.availableParallelism()
+// ignores a CPU quota under one core (12 at --cpus=0.5) and rounds others down (1 at --cpus=1.5). So
+// limits and container usage are read from the cgroup files this process is charged to, found through
+// /proc/self/cgroup and /proc/self/mountinfo, which covers cgroup v1 and v2 and a private or host
+// cgroup namespace alike. Off Linux, or where those files cannot be read, the limits fall back to the
+// host and the container-only figures are null. Nothing here throws: a figure that cannot be read is
+// null, and the heartbeat goes out regardless.
+// Event loop delay is sampled on a timer of this resolution, which every sample includes and which is
+// subtracted, so an idle loop reads close to zero.
+const LOOP_RESOLUTION_MS = 20;
+// cgroup v1 writes "no limit" as the largest page-aligned int64, not as a word.
+const V1_UNLIMITED = 2 ** 60;
+// mountinfo escapes spaces and other octal characters in paths as \NNN.
+const unescape = (s) => s.replace(/\\([0-7]{3})/g, (_, n) => String.fromCharCode(parseInt(n, 8)));
+function parseMountInfo(text) {
+    const mounts = [];
+    for (const line of text.split('\n')) {
+        const sep = line.indexOf(' - ');
+        if (sep < 0)
+            continue;
+        const pre = line.slice(0, sep).split(' ');
+        const post = line.slice(sep + 3).split(' ');
+        if (pre.length < 5 || post.length < 3)
+            continue;
+        mounts.push({ root: unescape(pre[3]), mountPoint: unescape(pre[4]), fsType: post[0], superOptions: post[2].split(',') });
+    }
+    return mounts;
+}
+// Maps a cgroup path, as /proc/self/cgroup gives it, to directories under the mount that shows it. A
+// mount's root is the part of the hierarchy it exposes: "/" for a whole hierarchy or a private cgroup
+// namespace, the container's own cgroup for Docker on cgroup v1.
+function hierarchy(prefix, mount, path) {
+    let rel = path;
+    if (mount.root !== '/') {
+        rel = path === mount.root || path.startsWith(mount.root + '/') ? path.slice(mount.root.length) : '';
+    }
+    const base = prefix + mount.mountPoint;
+    const parts = rel.split('/').filter(Boolean);
+    const dirs = [];
+    for (let i = parts.length; i >= 0; i--) {
+        dirs.push([base, ...parts.slice(0, i)].join('/'));
+    }
+    return { dirs };
+}
+// Finds the cgroup this process is charged to. `prefix` is prepended to every path read, for tests.
+export async function findCgroup(prefix = '') {
+    let self;
+    try {
+        self = await readFile(prefix + '/proc/self/cgroup', 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const entries = self.split('\n').filter(Boolean).map(line => {
+        const [id, controllers, ...path] = line.split(':');
+        return { id, controllers: controllers ? controllers.split(',') : [], path: path.join(':') };
+    });
+    // A sandbox can refuse mountinfo while allowing the rest (AppArmor under snap does). Then assume
+    // the usual layout, each hierarchy mounted whole under /sys/fs/cgroup: walking up from the path
+    // still reaches the mount's root, which is the container's own cgroup under a private namespace
+    // and under Docker's v1 mounts alike.
+    let mounts;
+    try {
+        mounts = parseMountInfo(await readFile(prefix + '/proc/self/mountinfo', 'utf8'));
+    }
+    catch {
+        mounts = entries.map(e => e.controllers.length
+            ? { root: '/', mountPoint: '/sys/fs/cgroup/' + e.controllers.join(','), fsType: 'cgroup', superOptions: e.controllers }
+            : { root: '/', mountPoint: '/sys/fs/cgroup', fsType: 'cgroup2', superOptions: [] });
+    }
+    // A v1 hierarchy for a controller wins over a v2 one: on a hybrid host the unified hierarchy is
+    // mounted but the cpu and memory controllers stay on v1.
+    const v1 = (controller) => {
+        const entry = entries.find(e => e.controllers.includes(controller));
+        const mount = mounts.find(m => m.fsType === 'cgroup' && m.superOptions.includes(controller));
+        return entry && mount ? hierarchy(prefix, mount, entry.path) : null;
+    };
+    const cpu = v1('cpu');
+    const memory = v1('memory');
+    if (cpu || memory) {
+        return { version: 1, cpu, memory };
+    }
+    const unified = entries.find(e => e.id === '0' && e.controllers.length === 0);
+    const mount = mounts.find(m => m.fsType === 'cgroup2');
+    if (unified && mount) {
+        const h = hierarchy(prefix, mount, unified.path);
+        return { version: 2, cpu: h, memory: h };
+    }
+    return null;
+}
+async function read(path) {
+    try {
+        return (await readFile(path, 'utf8')).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function statField(text, key) {
+    if (!text)
+        return null;
+    const m = new RegExp(`^${key} (\\d+)$`, 'm').exec(text);
+    return m ? Number(m[1]) : null;
+}
+// The tightest CPU quota in cores on this cgroup or a parent, and where it is set.
+async function cpuQuota(cg) {
+    if (!cg.cpu)
+        return null;
+    let best = null;
+    for (const dir of cg.cpu.dirs) {
+        let cores = null;
+        if (cg.version === 2) {
+            const [quota, period] = (await read(dir + '/cpu.max'))?.split(' ') ?? [];
+            if (quota && quota !== 'max' && Number(period) > 0)
+                cores = Number(quota) / Number(period);
+        }
+        else {
+            const quota = Number(await read(dir + '/cpu.cfs_quota_us'));
+            const period = Number(await read(dir + '/cpu.cfs_period_us'));
+            if (quota > 0 && period > 0)
+                cores = quota / period;
+        }
+        if (cores !== null && cores > 0 && (!best || cores < best.value))
+            best = { value: cores, dir };
+    }
+    return best;
+}
+// The tightest memory limit in bytes on this cgroup or a parent, and where it is set.
+async function memoryLimit(cg) {
+    if (!cg.memory)
+        return null;
+    let best = null;
+    for (const dir of cg.memory.dirs) {
+        const text = await read(dir + (cg.version === 2 ? '/memory.max' : '/memory.limit_in_bytes'));
+        if (!text || text === 'max')
+            continue;
+        const bytes = Number(text);
+        if (!(bytes > 0) || bytes >= V1_UNLIMITED)
+            continue;
+        if (!best || bytes < best.value)
+            best = { value: bytes, dir };
+    }
+    return best;
+}
+// Memory in use by the cgroup less its inactive file cache: the working set that container runtimes
+// and the kubelet compare against the limit, since inactive cache is reclaimed before anything is killed.
+async function workingSet(cg, dir) {
+    const usage = Number(await read(dir + (cg.version === 2 ? '/memory.current' : '/memory.usage_in_bytes')) ?? NaN);
+    if (!(usage >= 0))
+        return null;
+    const inactive = statField(await read(dir + '/memory.stat'), cg.version === 2 ? 'inactive_file' : 'total_inactive_file') ?? 0;
+    return Math.max(0, usage - inactive);
+}
+// Counts the CPUs this process may be scheduled on, from a list such as "0-3,8,10-11".
+export function countCpuList(list) {
+    let n = 0;
+    for (const part of list.split(',')) {
+        const m = /^(\d+)(?:-(\d+))?$/.exec(part.trim());
+        if (!m)
+            return null;
+        n += m[2] === undefined ? 1 : Number(m[2]) - Number(m[1]) + 1;
+    }
+    return n > 0 ? n : null;
+}
+async function allowedCpus(prefix) {
+    const status = await read(prefix + '/proc/self/status');
+    const list = status && /^Cpus_allowed_list:\s*(\S+)$/m.exec(status)?.[1];
+    const n = list ? countCpuList(list) : null;
+    return n ?? os.availableParallelism();
+}
+const round = (n, places) => Math.round(n * 10 ** places) / 10 ** places;
+class Nurse {
+    #prefix;
+    #cgroup = null;
+    #loop = null;
+    #elu = null;
+    #cpu = null;
+    #at = null;
+    #throttle = null;
+    constructor(prefix = '') {
+        this.#prefix = prefix;
+    }
+    start() {
+        this.#cgroup = findCgroup(this.#prefix).catch(() => null);
+        try {
+            this.#loop = monitorEventLoopDelay({ resolution: LOOP_RESOLUTION_MS });
+            this.#loop.enable();
+        }
+        catch {
+            this.#loop = null;
+        }
+        this.#cpu = null;
+        this.#at = null;
+        this.#elu = null;
+        this.#throttle = null;
+    }
+    stop() {
+        this.#loop?.disable();
+        this.#loop = null;
+    }
+    // Rates cover the time since the previous check. The first check after start() only sets the
+    // baseline, since at registration it would cover a few microseconds, so its rates are null.
+    async check() {
+        const first = this.#at === null;
+        const now = process.hrtime.bigint();
+        const cpuNow = process.cpuUsage();
+        const elapsedMicros = first ? 0 : Number(now - this.#at) / 1000;
+        const cpu = !first && this.#cpu && elapsedMicros > 0
+            ? ((cpuNow.user - this.#cpu.user) + (cpuNow.system - this.#cpu.system)) / elapsedMicros
+            : null;
+        this.#cpu = cpuNow;
+        this.#at = now;
+        let loopDelay = null;
+        let loopDelayMax = null;
+        if (this.#loop) {
+            if (!first && this.#loop.count > 0) {
+                loopDelay = Math.max(0, this.#loop.percentile(99) / 1e6 - LOOP_RESOLUTION_MS);
+                loopDelayMax = Math.max(0, this.#loop.max / 1e6 - LOOP_RESOLUTION_MS);
+            }
+            this.#loop.reset();
+        }
+        let loopUtilization = null;
+        try {
+            const next = performance.eventLoopUtilization();
+            // Bun's is a stub that always reads zero, which would chart as an idle loop.
+            if (next.idle === 0 && next.active === 0)
+                throw new Error('unsupported');
+            if (!first && this.#elu)
+                loopUtilization = performance.eventLoopUtilization(next, this.#elu).utilization;
+            this.#elu = next;
+        }
+        catch { }
+        let heapUsed = null;
+        let heapLimit = null;
+        try {
+            const heap = v8.getHeapStatistics();
+            heapUsed = heap.used_heap_size;
+            heapLimit = heap.heap_size_limit;
+        }
+        catch { }
+        let rss = null;
+        try {
+            rss = process.memoryUsage.rss();
+        }
+        catch { }
+        const cg = await this.#cgroup;
+        const quota = cg ? await cpuQuota(cg) : null;
+        const memLimit = cg ? await memoryLimit(cg) : null;
+        const cpus = await allowedCpus(this.#prefix);
+        return {
+            cgroup: cg?.version ?? null,
+            cpu: cpu === null ? null : round(cpu, 3),
+            cpuLimit: round(quota ? Math.min(quota.value, cpus) : cpus, 3),
+            cpuThrottled: cg && quota ? await this.#throttled(cg, quota.dir) : null,
+            rss,
+            heapUsed,
+            heapLimit,
+            memoryUsed: cg && memLimit ? await workingSet(cg, memLimit.dir) : null,
+            memoryLimit: memLimit ? memLimit.value : os.totalmem(),
+            loopDelay: loopDelay === null ? null : round(loopDelay, 1),
+            loopDelayMax: loopDelayMax === null ? null : round(loopDelayMax, 1),
+            loopUtilization: loopUtilization === null ? null : round(loopUtilization, 3)
+        };
+    }
+    // The share of CPU periods since the previous check in which the cgroup that holds the quota ran
+    // out of it and was paused. Null on the first check, or when the quota moved to another cgroup.
+    async #throttled(cg, dir) {
+        const text = await read(dir + '/cpu.stat');
+        const periods = statField(text, 'nr_periods');
+        const throttled = statField(text, 'nr_throttled');
+        if (periods === null || throttled === null)
+            return null;
+        const prev = this.#throttle;
+        this.#throttle = { dir, periods, throttled };
+        if (!prev || prev.dir !== dir)
+            return null;
+        const dp = periods - prev.periods;
+        return dp > 0 ? round((throttled - prev.throttled) / dp, 3) : 0;
+    }
+}
+export default Nurse;

package/dist/plans.d.ts

@@ -6,6 +6,10 @@ export interface SqlQuery {
 }
 export declare const PG_ERROR: {
     divisionByZero: string;
+    lockNotAvailable: string;
+    foreignKeyViolation: string;
+    undefinedTable: string;
+    checkViolation: string;
 };
 export declare const DEFAULT_SCHEMA = "pgboss";
 export declare const MIGRATE_RACE_MESSAGE = "division by zero";
@@ -90,12 +94,26 @@ export declare function createClockFunction(schema: string, options?: {
 export declare function createTableWarning(schema: string): string;
 export declare function createIndexWarning(schema: string): string;
 export declare function createTableJobDependency(schema: string): string;
+export declare const INSTANCE_QUIET_BEATS = 3;
+export declare const INSTANCE_RETENTION_DAYS = 7;
+export declare const INSTANCE_DEAD_KEPT_PER_NAME = 20;
+export declare const INSTANCE_DEAD_KEPT = 1000;
+export declare function pruneInstanceLives(schema: string, keep: number): string;
+export declare function trimDeadInstances(schema: string, keep: number): string;
+export declare function countCrashRestarts(schema: string): string;
+export declare function crashRecountAt(schema: string): string;
+export declare function registerInstance(schema: string): string;
+export declare function heartbeatInstance(schema: string): string;
+export declare function stopInstance(schema: string): string;
+export declare function deleteOldInstances(schema: string, days: number): string;
+export declare function getInstances(schema: string): string;
 export declare function createIndexJobDependencyParent(schema: string): string;
+export declare function createTableInstance(schema: string): string;
 export declare function jobTableFormatFunction(schema: string): string;
 export declare function createQueue(schema: string, name: string, options: unknown, noAdvisoryLocks?: boolean): string;
 export declare function notifyChannelSql(schema: string): string;
 export declare function notifyQueue(schema: string, name: string): string;
-export declare function deleteQueue(schema: string, name: string, noAdvisoryLocks?: boolean): string;
+export declare function deleteQueue(schema: string, name: string, noAdvisoryLocks?: boolean, partitioned?: boolean): string;
 export declare function trySetQueueMonitorTime(schema: string, queues: string[], seconds: number, skipLocked?: boolean): SqlQuery;
 export declare function setMonitorBackoff(schema: string, elapsedSeconds: number): SqlQuery;
 export declare function trySetQueueDeletionTime(schema: string, queues: string[], seconds: number, skipLocked?: boolean): SqlQuery;
@@ -105,6 +123,7 @@ export declare function trySetFlowTime(schema: string, seconds: number): string;
 export declare function trySetReindexTime(schema: string, seconds: number): string;
 export declare function queueClaimSkipLocked(backend: string | undefined, noSkipLocked?: boolean): boolean;
 export declare function updateQueue(schema: string): string;
+export declare function currentDatabase(): string;
 export declare function getQueues(schema: string, names?: string[]): SqlQuery;
 export declare function deleteJobsById(schema: string, table: string, fenced?: boolean): string;
 export declare function deleteQueuedJobs(schema: string, table: string): string;
@@ -165,6 +184,7 @@ interface FetchJobOptions {
     policy: string | undefined;
     limit: number;
     includeMetadata?: boolean;
+    includeTraceContext?: boolean;
     priority?: boolean;
     orderByCreatedOn?: boolean;
     ignoreStartAfter?: boolean;
@@ -204,8 +224,9 @@ interface InsertJobsOptions {
     returnId?: boolean;
     notify?: boolean;
     slots?: boolean;
+    upsertByKey?: boolean;
 }
-export declare function insertJobs(schema: string, { table, name, returnId, notify, slots }: InsertJobsOptions): string;
+export declare function insertJobs(schema: string, { table, name, returnId, notify, slots, upsertByKey }: InsertJobsOptions): string;
 export declare function insertFlowJobs(schema: string, { table, name }: {
     table: string;
     name: string;
@@ -244,6 +265,9 @@ export interface DeltaWindowOptions {
 }
 export declare function deltaResetMax(intervalSeconds: number): string;
 export declare function trueUpQueueStats(schema: string, table: string, queues: string[], noAdvisoryLocks?: boolean, window?: DeltaWindowOptions): string;
+export declare const LATENCY_BINS = 46;
+export declare const LATENCY_SLOTS: number;
+export declare const LATENCY_MIN_SECONDS = 0.01;
 export declare function getQueueStats(schema: string, table: string, queues: string[], throughput?: boolean, window?: DeltaWindowOptions): SqlQuery;
 export declare const READY_HISTORY_SIZE = 60;
 export declare function cacheQueueStats(schema: string, table: string, queues: string[], noAdvisoryLocks?: boolean, throughput?: boolean, window?: DeltaWindowOptions): string;
@@ -287,6 +311,7 @@ interface QueuePartition {
     table: string;
     policy?: string | null;
 }
+export declare function uninstall(schema: string, partitioned?: boolean): string;
 export declare const EXPECTED_JOB_STATES: readonly string[];
 export declare function expectedManagedTables(schema: string, partitioned: boolean, partitions?: QueuePartition[]): string[];
 export declare function expectedManagedColumns(schema: string, partitioned: boolean, partitions?: QueuePartition[]): ExpectedColumns[];