sidekiq-ts 1.0.0

package/dist/api.js

@@ -0,0 +1,679 @@
+import { Client } from "./client.js";
+import { dumpJson, loadJson } from "./json.js";
+import { Sidekiq } from "./sidekiq.js";
+const getRedis = async (config) => (config ?? Sidekiq.defaultConfiguration).getRedisClient();
+export class Stats {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async processed() {
+        const redis = await getRedis(this.config);
+        return Number(await redis.get("stat:processed")) || 0;
+    }
+    async failed() {
+        const redis = await getRedis(this.config);
+        return Number(await redis.get("stat:failed")) || 0;
+    }
+    async workersSize() {
+        const redis = await getRedis(this.config);
+        const processes = await redis.sMembers("processes");
+        if (processes.length === 0) {
+            return 0;
+        }
+        const pipeline = redis.multi();
+        for (const key of processes) {
+            pipeline.hGet(key, "busy");
+        }
+        const result = await pipeline.exec();
+        return (result ?? []).reduce((sum, value) => sum + Number(value ?? 0), 0);
+    }
+    async scheduledSize() {
+        const redis = await getRedis(this.config);
+        return Number(await redis.sendCommand(["ZCARD", "schedule"])) || 0;
+    }
+    async retrySize() {
+        const redis = await getRedis(this.config);
+        return Number(await redis.sendCommand(["ZCARD", "retry"])) || 0;
+    }
+    async deadSize() {
+        const redis = await getRedis(this.config);
+        return Number(await redis.sendCommand(["ZCARD", "dead"])) || 0;
+    }
+    async processesSize() {
+        const redis = await getRedis(this.config);
+        return Number(await redis.sendCommand(["SCARD", "processes"])) || 0;
+    }
+    async enqueued() {
+        const redis = await getRedis(this.config);
+        const queues = await redis.sMembers("queues");
+        if (queues.length === 0) {
+            return 0;
+        }
+        const pipeline = redis.multi();
+        for (const queue of queues) {
+            pipeline.lLen(`queue:${queue}`);
+        }
+        const result = await pipeline.exec();
+        return (result ?? []).reduce((sum, value) => sum + Number(value ?? 0), 0);
+    }
+    async defaultQueueLatency() {
+        const redis = await getRedis(this.config);
+        const entry = (await redis.sendCommand([
+            "LINDEX",
+            "queue:default",
+            "-1",
+        ]));
+        if (!entry) {
+            return 0;
+        }
+        let payload;
+        try {
+            payload = loadJson(entry);
+        }
+        catch {
+            return 0;
+        }
+        const enqueuedAt = Number(payload.enqueued_at);
+        if (!Number.isFinite(enqueuedAt) || enqueuedAt <= 0) {
+            return 0;
+        }
+        const nowMs = Date.now();
+        const diffMs = enqueuedAt > 1_000_000_000_000
+            ? nowMs - enqueuedAt
+            : nowMs - enqueuedAt * 1000;
+        return diffMs / 1000;
+    }
+    async reset(...stats) {
+        const targets = stats.length === 0 ? ["processed", "failed"] : stats.map(String);
+        const allowed = targets.filter((stat) => stat === "processed" || stat === "failed");
+        if (allowed.length === 0) {
+            return;
+        }
+        const redis = await getRedis(this.config);
+        const args = [];
+        for (const stat of allowed) {
+            args.push(`stat:${stat}`, "0");
+        }
+        await redis.mSet(args);
+    }
+    async queues() {
+        const redis = await getRedis(this.config);
+        const queues = await redis.sMembers("queues");
+        if (queues.length === 0) {
+            return {};
+        }
+        const pipeline = redis.multi();
+        for (const queue of queues) {
+            pipeline.lLen(`queue:${queue}`);
+        }
+        const result = await pipeline.exec();
+        const pairs = queues.map((queue, index) => [
+            queue,
+            Number(result?.[index] ?? 0),
+        ]);
+        pairs.sort((a, b) => b[1] - a[1]);
+        return Object.fromEntries(pairs);
+    }
+}
+export class StatsHistory {
+    config;
+    daysPrevious;
+    startDate;
+    constructor(daysPrevious, startDate = new Date(), config) {
+        if (daysPrevious < 1 || daysPrevious > 5 * 365) {
+            throw new Error("daysPrevious must be between 1 and 1825");
+        }
+        this.config = config;
+        this.daysPrevious = daysPrevious;
+        this.startDate = new Date(Date.UTC(startDate.getUTCFullYear(), startDate.getUTCMonth(), startDate.getUTCDate()));
+    }
+    processed() {
+        return this.dateStat("processed");
+    }
+    failed() {
+        return this.dateStat("failed");
+    }
+    async dateStat(stat) {
+        const dates = [];
+        for (let i = 0; i < this.daysPrevious; i += 1) {
+            const date = new Date(this.startDate);
+            date.setUTCDate(this.startDate.getUTCDate() - i);
+            dates.push(date.toISOString().slice(0, 10));
+        }
+        const keys = dates.map((date) => `stat:${stat}:${date}`);
+        const redis = await getRedis(this.config);
+        const values = await redis.mGet(keys);
+        const result = {};
+        dates.forEach((date, index) => {
+            result[date] = Number(values[index] ?? 0);
+        });
+        return result;
+    }
+}
+export class Queue {
+    config;
+    name;
+    constructor(name = "default", config) {
+        this.name = name;
+        this.config = config;
+    }
+    static async all(config) {
+        const redis = await getRedis(config);
+        const queues = await redis.sMembers("queues");
+        return queues.sort().map((queue) => new Queue(queue, config));
+    }
+    async size() {
+        const redis = await getRedis(this.config);
+        return Number(await redis.lLen(`queue:${this.name}`));
+    }
+    async clear() {
+        const redis = await getRedis(this.config);
+        const pipeline = redis.multi();
+        pipeline.unlink(`queue:${this.name}`);
+        pipeline.sRem("queues", [this.name]);
+        await pipeline.exec();
+    }
+    async entries(start = 0, stop = -1) {
+        const redis = await getRedis(this.config);
+        const range = await redis.lRange(`queue:${this.name}`, start, stop);
+        return range.map((entry) => loadJson(entry));
+    }
+    async latency() {
+        const redis = await getRedis(this.config);
+        const entry = (await redis.sendCommand([
+            "LINDEX",
+            `queue:${this.name}`,
+            "-1",
+        ]));
+        if (!entry) {
+            return 0;
+        }
+        let payload;
+        try {
+            payload = loadJson(entry);
+        }
+        catch {
+            return 0;
+        }
+        const enqueuedAt = Number(payload.enqueued_at);
+        if (!Number.isFinite(enqueuedAt) || enqueuedAt <= 0) {
+            return 0;
+        }
+        const nowMs = Date.now();
+        const diffMs = enqueuedAt > 1_000_000_000_000
+            ? nowMs - enqueuedAt
+            : nowMs - enqueuedAt * 1000;
+        return diffMs / 1000;
+    }
+    async *each(pageSize = 50) {
+        const redis = await getRedis(this.config);
+        const initialSize = await redis.lLen(`queue:${this.name}`);
+        let deletedSize = 0;
+        let page = 0;
+        while (true) {
+            const start = Math.max(page * pageSize - deletedSize, 0);
+            const end = start + pageSize - 1;
+            const entries = await redis.lRange(`queue:${this.name}`, start, end);
+            if (entries.length === 0) {
+                break;
+            }
+            page += 1;
+            for (const entry of entries) {
+                yield new JobRecord(entry, this.name, this.config);
+            }
+            const size = await redis.lLen(`queue:${this.name}`);
+            deletedSize = Math.max(initialSize - size, 0);
+        }
+    }
+    async findJob(jid) {
+        for await (const record of this.each()) {
+            if (record.jid === jid) {
+                return record;
+            }
+        }
+        return null;
+    }
+}
+export class JobRecord {
+    queue;
+    value;
+    payload;
+    config;
+    constructor(value, queue, config) {
+        this.value = value;
+        this.queue = queue;
+        this.config = config;
+        this.payload = loadJson(value);
+    }
+    get jid() {
+        return typeof this.payload.jid === "string" ? this.payload.jid : undefined;
+    }
+    async delete() {
+        const redis = await getRedis(this.config);
+        const removed = await redis.lRem(`queue:${this.queue}`, 1, this.value);
+        return removed > 0;
+    }
+}
+class SortedSet {
+    config;
+    key;
+    constructor(key, config) {
+        this.key = key;
+        this.config = config;
+    }
+    async size() {
+        const redis = await getRedis(this.config);
+        return Number(await redis.sendCommand(["ZCARD", this.key]));
+    }
+    async clear() {
+        const redis = await getRedis(this.config);
+        await redis.sendCommand(["ZREMRANGEBYRANK", this.key, "0", "-1"]);
+    }
+}
+export class SortedEntry {
+    score;
+    payload;
+    value;
+    parent;
+    constructor(parent, score, value) {
+        this.parent = parent;
+        this.score = score;
+        this.value = value;
+        this.payload = loadJson(value);
+    }
+    get jid() {
+        return typeof this.payload.jid === "string" ? this.payload.jid : undefined;
+    }
+    async delete() {
+        await this.parent.deleteByValue(this.value);
+    }
+    async reschedule(at) {
+        await this.parent.rescheduleValue(this.value, at);
+    }
+    async addToQueue() {
+        await this.parent.addToQueueValue(this.value);
+    }
+    async retry() {
+        await this.parent.retryValue(this.value);
+    }
+    async kill() {
+        await this.parent.killValue(this.value);
+    }
+}
+class JobSet extends SortedSet {
+    async entries(start = 0, stop = -1) {
+        const redis = await getRedis(this.config);
+        const response = (await redis.sendCommand([
+            "ZRANGE",
+            this.key,
+            String(start),
+            String(stop),
+            "WITHSCORES",
+        ]));
+        const entries = [];
+        for (let i = 0; i < response.length; i += 2) {
+            const value = response[i];
+            const score = Number(response[i + 1]);
+            entries.push(new SortedEntry(this, score, value));
+        }
+        return entries;
+    }
+    async *scan(match, count = 100) {
+        const redis = await getRedis(this.config);
+        const pattern = match.includes("*") ? match : `*${match}*`;
+        let cursor = "0";
+        do {
+            const response = (await redis.sendCommand([
+                "ZSCAN",
+                this.key,
+                cursor,
+                "MATCH",
+                pattern,
+                "COUNT",
+                String(count),
+            ]));
+            cursor = response[0];
+            const items = response[1] ?? [];
+            for (let i = 0; i < items.length; i += 2) {
+                const value = items[i];
+                const score = Number(items[i + 1]);
+                yield new SortedEntry(this, score, value);
+            }
+        } while (cursor !== "0");
+    }
+    // biome-ignore lint/suspicious/useAwait: yield* delegates to an async generator
+    async *each() {
+        yield* this.scan("*");
+    }
+    async findJob(jid) {
+        for await (const entry of this.scan(jid)) {
+            if (entry.jid === jid) {
+                return entry;
+            }
+        }
+        return null;
+    }
+    async schedule(timestamp, payload) {
+        const redis = await getRedis(this.config);
+        await redis.zAdd(this.key, [
+            { score: timestamp, value: dumpJson(payload) },
+        ]);
+    }
+    async retryAll() {
+        const client = new Client({ config: this.config });
+        await this.popEach(async (value) => {
+            const payload = loadJson(value);
+            if (typeof payload.retry_count === "number") {
+                payload.retry_count -= 1;
+            }
+            await client.push(payload);
+        });
+    }
+    async killAll() {
+        const dead = new DeadSet(this.config);
+        await this.popEach(async (value) => {
+            await dead.kill(value, { trim: false });
+        });
+        await dead.trim();
+    }
+    async deleteByValue(value) {
+        const redis = await getRedis(this.config);
+        await redis.zRem(this.key, value);
+    }
+    async rescheduleValue(value, at) {
+        const redis = await getRedis(this.config);
+        await redis.zAdd(this.key, [{ score: at, value }]);
+    }
+    async addToQueueValue(value) {
+        const redis = await getRedis(this.config);
+        const removed = await redis.zRem(this.key, value);
+        if (removed === 0) {
+            return;
+        }
+        const payload = loadJson(value);
+        const client = new Client({ config: this.config });
+        await client.push(payload);
+    }
+    async retryValue(value) {
+        const redis = await getRedis(this.config);
+        const removed = await redis.zRem(this.key, value);
+        if (removed === 0) {
+            return;
+        }
+        const payload = loadJson(value);
+        if (typeof payload.retry_count === "number") {
+            payload.retry_count -= 1;
+        }
+        const client = new Client({ config: this.config });
+        await client.push(payload);
+    }
+    async killValue(value) {
+        const redis = await getRedis(this.config);
+        const removed = await redis.zRem(this.key, value);
+        if (removed === 0) {
+            return;
+        }
+        const dead = new DeadSet(this.config);
+        await dead.kill(value);
+    }
+    async popEach(fn) {
+        const redis = await getRedis(this.config);
+        while (true) {
+            const response = (await redis.sendCommand([
+                "ZPOPMIN",
+                this.key,
+                "1",
+            ]));
+            if (!response || response.length === 0) {
+                break;
+            }
+            const value = response[0];
+            await fn(value);
+        }
+    }
+}
+export class ScheduledSet extends JobSet {
+    constructor(config) {
+        super("schedule", config);
+    }
+}
+export class RetrySet extends JobSet {
+    constructor(config) {
+        super("retry", config);
+    }
+}
+export class DeadSet extends JobSet {
+    constructor(config) {
+        super("dead", config);
+    }
+    async kill(payload, options = {}) {
+        const redis = await getRedis(this.config);
+        const nowSeconds = Date.now() / 1000;
+        const value = typeof payload === "string" ? payload : dumpJson(payload);
+        await redis.zAdd(this.key, [{ score: nowSeconds, value }]);
+        if (options.trim !== false) {
+            await this.trim();
+        }
+    }
+    async trim() {
+        const redis = await getRedis(this.config);
+        const maxJobs = this.config?.deadMaxJobs ?? Sidekiq.defaultConfiguration.deadMaxJobs;
+        const timeout = this.config?.deadTimeoutInSeconds ??
+            Sidekiq.defaultConfiguration.deadTimeoutInSeconds;
+        const cutoff = Date.now() / 1000 - timeout;
+        const pipeline = redis.multi();
+        pipeline.zRemRangeByScore(this.key, 0, cutoff);
+        pipeline.zRemRangeByRank(this.key, 0, -maxJobs);
+        await pipeline.exec();
+    }
+}
+export class ProcessSet {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    static async get(identity, config) {
+        const redis = await getRedis(config);
+        const pipeline = redis.multi();
+        pipeline.sIsMember("processes", identity);
+        pipeline.hGetAll(identity);
+        const result = await pipeline.exec();
+        const exists = Number(result?.[0] ?? 0);
+        const raw = (result?.[1] ?? {});
+        if (exists === 0 || Object.keys(raw).length === 0) {
+            return null;
+        }
+        const info = raw.info
+            ? loadJson(raw.info)
+            : {};
+        return {
+            identity,
+            info,
+            busy: Number(raw.busy ?? 0),
+            beat: Number(raw.beat ?? 0),
+            quiet: raw.quiet === "true",
+            rtt_us: Number(raw.rtt_us ?? 0),
+            rss: Number(raw.rss ?? 0),
+        };
+    }
+    async entries() {
+        const redis = await getRedis(this.config);
+        const processes = await redis.sMembers("processes");
+        if (processes.length === 0) {
+            return [];
+        }
+        const pipeline = redis.multi();
+        for (const key of processes) {
+            pipeline.hGetAll(key);
+        }
+        const result = await pipeline.exec();
+        return processes.map((identity, index) => {
+            const raw = (result?.[index] ?? {});
+            const info = raw.info
+                ? loadJson(raw.info)
+                : {};
+            return {
+                identity,
+                info,
+                busy: Number(raw.busy ?? 0),
+                beat: Number(raw.beat ?? 0),
+                quiet: raw.quiet === "true",
+                rtt_us: Number(raw.rtt_us ?? 0),
+                rss: Number(raw.rss ?? 0),
+            };
+        });
+    }
+    async size() {
+        const redis = await getRedis(this.config);
+        return Number(await redis.sCard("processes"));
+    }
+    async totalConcurrency() {
+        const entries = await this.entries();
+        return entries.reduce((sum, entry) => sum + Number(entry.info.concurrency ?? 0), 0);
+    }
+    async totalRss() {
+        const entries = await this.entries();
+        return entries.reduce((sum, entry) => sum + Number(entry.rss ?? 0), 0);
+    }
+    async cleanup() {
+        const redis = await getRedis(this.config);
+        const lock = await redis.set("process_cleanup", "1", { NX: true, EX: 60 });
+        if (lock !== "OK") {
+            return 0;
+        }
+        const processes = await redis.sMembers("processes");
+        if (processes.length === 0) {
+            return 0;
+        }
+        const pipeline = redis.multi();
+        for (const key of processes) {
+            pipeline.hGet(key, "info");
+        }
+        const result = await pipeline.exec();
+        const toPrune = processes.filter((_, index) => !result?.[index]);
+        if (toPrune.length === 0) {
+            return 0;
+        }
+        await redis.sRem("processes", toPrune);
+        return toPrune.length;
+    }
+}
+/**
+ * Represents a single Sidekiq process and allows remote signaling.
+ */
+export class Process {
+    config;
+    identity;
+    info;
+    busy;
+    beat;
+    quiet;
+    rtt_us;
+    rss;
+    constructor(entry, config) {
+        this.config = config;
+        this.identity = entry.identity;
+        this.info = entry.info;
+        this.busy = entry.busy;
+        this.beat = entry.beat;
+        this.quiet = entry.quiet;
+        this.rtt_us = entry.rtt_us;
+        this.rss = entry.rss;
+    }
+    get tag() {
+        return this.info.tag;
+    }
+    get labels() {
+        return this.info.labels ?? [];
+    }
+    get queues() {
+        return this.info.queues ?? [];
+    }
+    get version() {
+        return this.info.version;
+    }
+    get embedded() {
+        return this.info.embedded === true;
+    }
+    /**
+     * Whether this process is quiet or shutting down.
+     */
+    get stopping() {
+        return this.quiet;
+    }
+    /**
+     * Signal this process to stop processing new jobs.
+     * It will continue to execute jobs it has already fetched.
+     * This method is asynchronous and it can take 5-10 seconds
+     * for the process to quiet.
+     */
+    async quietProcess() {
+        if (this.embedded) {
+            throw new Error("Can't quiet an embedded process");
+        }
+        await this.signal("TSTP");
+    }
+    /**
+     * Signal this process to shutdown.
+     * It will shutdown within its configured timeout value, default 25 seconds.
+     * This method is asynchronous and it can take 5-10 seconds
+     * for the process to start shutting down.
+     */
+    async stopProcess() {
+        if (this.embedded) {
+            throw new Error("Can't stop an embedded process");
+        }
+        await this.signal("TERM");
+    }
+    /**
+     * Signal this process to log its current worker state.
+     * Useful for debugging frozen or deadlocked processes.
+     * This method is asynchronous and it can take 5-10 seconds.
+     */
+    async dumpThreads() {
+        await this.signal("TTIN");
+    }
+    async signal(sig) {
+        const redis = await getRedis(this.config);
+        const key = `${this.identity}-signals`;
+        const pipeline = redis.multi();
+        pipeline.lPush(key, sig);
+        pipeline.expire(key, 60);
+        await pipeline.exec();
+    }
+}
+export class Workers {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async entries() {
+        const redis = await getRedis(this.config);
+        const processes = await redis.sMembers("processes");
+        if (processes.length === 0) {
+            return [];
+        }
+        const pipeline = redis.multi();
+        for (const key of processes) {
+            pipeline.hGetAll(`${key}:work`);
+        }
+        const result = await pipeline.exec();
+        const entries = [];
+        for (const [index, identity] of processes.entries()) {
+            const work = (result?.[index] ?? {});
+            for (const [thread, value] of Object.entries(work)) {
+                const parsed = loadJson(value);
+                const payload = loadJson(parsed.payload);
+                entries.push({
+                    process: identity,
+                    thread,
+                    queue: parsed.queue,
+                    payload,
+                    run_at: parsed.run_at,
+                });
+            }
+        }
+        return entries;
+    }
+}

package/dist/backtrace.d.ts

@@ -0,0 +1,3 @@
+export declare const extractBacktrace: (error: Error) => string[];
+export declare const compressBacktrace: (lines: string[]) => string;
+//# sourceMappingURL=backtrace.d.ts.map

package/dist/backtrace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backtrace.d.ts","sourceRoot":"","sources":["../src/backtrace.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,GAAI,OAAO,KAAK,KAAG,MAAM,EASrD,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,OAAO,MAAM,EAAE,KAAG,MAInD,CAAC"}

package/dist/backtrace.js

@@ -0,0 +1,16 @@
+import { deflateSync } from "node:zlib";
+export const extractBacktrace = (error) => {
+    if (!error.stack) {
+        return [];
+    }
+    const lines = error.stack.split("\n").map((line) => line.trim());
+    if (lines.length > 0 && lines[0].startsWith(error.name)) {
+        return lines.slice(1);
+    }
+    return lines;
+};
+export const compressBacktrace = (lines) => {
+    const serialized = JSON.stringify(lines);
+    const compressed = deflateSync(serialized);
+    return compressed.toString("base64");
+};