@zintrust/core 0.1.40 → 0.1.42

package/src/tools/queue/JobRecoveryDaemon.js

@@ -0,0 +1,303 @@
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { useDatabase } from '../../orm/Database.js';
+import { JobStateTracker } from './JobStateTracker.js';
+import { Queue } from './Queue.js';
+const parsePayload = (payload) => {
+    if (payload !== null && payload !== undefined && typeof payload === 'object') {
+        return payload;
+    }
+    return { payload };
+};
+const shouldManualReview = (record) => {
+    const error = String(record.lastError ?? '').toLowerCase();
+    return error.includes('fatal') || error.includes('corrupt');
+};
+const replayReasonCodes = new Set([
+    'bug_fixed',
+    'transient_dependency',
+    'operator_override',
+]);
+const resolveLimit = (requested) => {
+    const maxBatch = Math.max(1, Env.getInt('DLQ_REPLAY_MAX_BATCH_SIZE', 25));
+    if (typeof requested !== 'number' || Number.isFinite(requested) === false || requested <= 0) {
+        return maxBatch;
+    }
+    return Math.min(maxBatch, Math.floor(requested));
+};
+const resolveRate = (requested) => {
+    const maxQps = Math.max(1, Env.getInt('DLQ_REPLAY_MAX_QPS', 5));
+    if (typeof requested !== 'number' || Number.isFinite(requested) === false || requested <= 0) {
+        return maxQps;
+    }
+    return Math.min(maxQps, Math.floor(requested));
+};
+const resolveMinAgeMs = (requested) => {
+    const minAllowed = Math.max(0, Env.getInt('DLQ_REPLAY_MIN_AGE_MS', 60000));
+    if (typeof requested !== 'number' || Number.isFinite(requested) === false || requested < 0) {
+        return minAllowed;
+    }
+    return Math.max(minAllowed, Math.floor(requested));
+};
+const validateReplayReasonCode = (reasonCode) => {
+    if (replayReasonCodes.has(reasonCode))
+        return;
+    throw ErrorFactory.createConfigError(`Unsupported DLQ replay reason code: ${reasonCode}`);
+};
+const validateReplayActor = (replayedBy) => {
+    if (replayedBy.trim().length === 0) {
+        throw ErrorFactory.createConfigError('DLQ replay actor is required');
+    }
+    const allowedActorsRaw = Env.get('DLQ_REPLAY_ALLOWED_ACTORS', '').trim();
+    if (allowedActorsRaw.length === 0)
+        return;
+    const allowedActors = allowedActorsRaw
+        .split(',')
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+    if (allowedActors.length === 0)
+        return;
+    if (allowedActors.includes(replayedBy.trim()))
+        return;
+    throw ErrorFactory.createConfigError(`DLQ replay actor is not allowed: ${replayedBy}`);
+};
+const isReplayEligible = (record, minAgeMs) => {
+    if (record.status !== 'dead_letter')
+        return false;
+    const updated = new Date(record.updatedAt).getTime();
+    if (Number.isNaN(updated))
+        return false;
+    return updated <= Date.now() - minAgeMs;
+};
+const toReplayPayload = (record, reasonCode, replayedBy) => {
+    const parsed = parsePayload(record.payload);
+    const lineage = {
+        originalJobId: record.jobId,
+        replayReasonCode: reasonCode,
+        replayedBy,
+        replayedAt: new Date().toISOString(),
+    };
+    const existingLineage = parsed['__dlqReplayLineage'];
+    const lineageArray = Array.isArray(existingLineage)
+        ? [...existingLineage.map((entry) => ({ ...entry })), lineage]
+        : [lineage];
+    return {
+        ...parsed,
+        __dlqReplayLineage: lineageArray,
+    };
+};
+export const JobRecoveryDaemon = Object.freeze({
+    async recoverOne(record) {
+        const maxAttempts = typeof record.maxAttempts === 'number' ? record.maxAttempts : 3;
+        if (record.attempts >= maxAttempts) {
+            await JobStateTracker.setTerminalStatus({
+                queueName: record.queueName,
+                jobId: record.jobId,
+                status: 'dead_letter',
+                reason: 'Max retry attempts reached during recovery',
+            });
+            return 'dead_letter';
+        }
+        if (shouldManualReview(record)) {
+            await JobStateTracker.setTerminalStatus({
+                queueName: record.queueName,
+                jobId: record.jobId,
+                status: 'manual_review',
+                reason: 'Fatal recovery signature detected',
+            });
+            return 'manual_review';
+        }
+        const payload = parsePayload(record.payload);
+        // 30s, 1m, 3m backoff strategy
+        const getBackoffMs = (attempt) => {
+            if (attempt === 0)
+                return 30000;
+            if (attempt === 1)
+                return 60000;
+            return 180000;
+        };
+        const backoffMs = getBackoffMs(record.attempts);
+        try {
+            await Queue.enqueue(record.queueName, {
+                ...payload,
+                uniqueId: record.jobId, // Preserves job ID (prevents duplication)
+                attempts: maxAttempts,
+                _currentAttempts: record.attempts + 1,
+                timestamp: Date.now() + backoffMs,
+            });
+            // Once the job is in QUEUE_DRIVER (or already exists), we never re-enqueue from DB/recovery again.
+            await JobStateTracker.handedOffToQueue({
+                queueName: record.queueName,
+                jobId: record.jobId,
+                reason: 'Enqueue-fallback job handed off to QUEUE_DRIVER',
+            });
+            return 'requeued';
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const message = errorMessage.toLowerCase();
+            if (message.includes('jobid') && message.includes('already exists')) {
+                await JobStateTracker.handedOffToQueue({
+                    queueName: record.queueName,
+                    jobId: record.jobId,
+                    reason: 'Job already exists in queue driver',
+                });
+                return 'requeued';
+            }
+            await JobStateTracker.pendingRecovery({
+                queueName: record.queueName,
+                jobId: record.jobId,
+                reason: 'Enqueue-fallback retry failed during recovery daemon run',
+                attempts: record.attempts + 1,
+                maxAttempts,
+                retryAt: new Date(Date.now() + backoffMs).toISOString(),
+                error,
+            });
+            throw error;
+        }
+    },
+    async runOnce() {
+        const minAgeMs = Math.max(0, Env.getInt('JOB_RECOVERY_MIN_AGE_MS', 5000));
+        const candidates = JobStateTracker.listRecoverable(minAgeMs);
+        const persisted = await listRecoverableFromPersistence(minAgeMs);
+        // De-dupe jobs that exist in both in-memory tracker and persistence.
+        const seen = new Set();
+        const allCandidates = [...candidates, ...persisted].filter((row) => {
+            const key = `${row.queueName}:${row.jobId}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        let requeued = 0;
+        let deadLetter = 0;
+        let manualReview = 0;
+        const concurrency = 10;
+        const batches = [];
+        for (let offset = 0; offset < allCandidates.length; offset += concurrency) {
+            const slice = allCandidates.slice(offset, offset + concurrency);
+            batches.push(Promise.all(slice.map(async (candidate) => this.recoverOne(candidate))));
+        }
+        const batchResults = await Promise.all(batches);
+        batchResults.flat().forEach((result) => {
+            if (result === 'requeued')
+                requeued += 1;
+            if (result === 'dead_letter')
+                deadLetter += 1;
+            if (result === 'manual_review')
+                manualReview += 1;
+        });
+        if (allCandidates.length > 0) {
+            Logger.info('Queue recovery daemon completed scan', {
+                scanned: allCandidates.length,
+                requeued,
+                deadLetter,
+                manualReview,
+            });
+        }
+        return {
+            scanned: allCandidates.length,
+            requeued,
+            deadLetter,
+            manualReview,
+        };
+    },
+    async replayDeadLetter(input) {
+        validateReplayReasonCode(input.reasonCode);
+        validateReplayActor(input.replayedBy);
+        const limit = resolveLimit(input.limit);
+        const maxPerSecond = resolveRate(input.maxPerSecond);
+        const minAgeMs = resolveMinAgeMs(input.minAgeMs);
+        const replayBudget = Math.max(1, maxPerSecond);
+        const candidates = JobStateTracker.list({
+            queueName: input.queueName,
+            status: 'dead_letter',
+            limit,
+        })
+            .filter((record) => isReplayEligible(record, minAgeMs))
+            .slice(0, replayBudget);
+        let replayed = 0;
+        let skipped = 0;
+        await candidates.reduce(async (chain, candidate) => {
+            await chain;
+            if (candidate.queueName.trim().length === 0) {
+                skipped += 1;
+                return;
+            }
+            const replayPayload = toReplayPayload(candidate, input.reasonCode, input.replayedBy.trim());
+            const replayJobId = await Queue.enqueue(candidate.queueName, replayPayload);
+            await JobStateTracker.setTerminalStatus({
+                queueName: candidate.queueName,
+                jobId: candidate.jobId,
+                status: 'dead_letter',
+                reason: `DLQ replayed (${input.reasonCode}) by ${input.replayedBy.trim()} as ${replayJobId}`,
+            });
+            replayed += 1;
+        }, Promise.resolve());
+        Logger.info('DLQ replay governance batch completed', {
+            scanned: candidates.length,
+            replayed,
+            skipped,
+            reasonCode: input.reasonCode,
+            replayedBy: input.replayedBy.trim(),
+            queueName: input.queueName,
+            limit,
+            maxPerSecond,
+            minAgeMs,
+        });
+        return {
+            scanned: candidates.length,
+            replayed,
+            skipped,
+        };
+    },
+});
+const toSqlDateTime = (value) => value.toISOString().slice(0, 19).replace('T', ' ');
+const getPersistenceDb = () => useDatabase(undefined, Env.get('JOB_TRACKING_DB_CONNECTION', 'default'));
+const listRecoverableFromPersistence = async (minAgeMs) => {
+    if (!Env.getBool('JOB_TRACKING_PERSISTENCE_ENABLED', false))
+        return [];
+    const db = getPersistenceDb();
+    const cutoff = new Date(Date.now() - Math.max(0, Math.floor(minAgeMs)));
+    const rows = await db
+        .table(Env.get('JOB_TRACKING_DB_TABLE', 'zintrust_jobs'))
+        .select('queue_name', 'job_id', 'attempts', 'max_attempts', 'payload_json', 'retry_at', 'updated_at')
+        .where('status', '=', 'pending_recovery')
+        .where('updated_at', '<=', toSqlDateTime(cutoff))
+        .limit(Math.max(1, Env.getInt('JOB_RECOVERY_DB_SCAN_LIMIT', 100)))
+        .get();
+    return (rows ?? []).map((row) => {
+        let payload = {};
+        try {
+            payload = JSON.parse(String(row.payload_json ?? '{}'));
+        }
+        catch {
+            payload = {};
+        }
+        const attempts = typeof row.attempts === 'number' && Number.isFinite(row.attempts)
+            ? Math.max(0, Math.floor(row.attempts))
+            : 0;
+        const maxAttempts = typeof row.max_attempts === 'number' && Number.isFinite(row.max_attempts)
+            ? Math.max(1, Math.floor(row.max_attempts))
+            : undefined;
+        const updatedAtRaw = typeof row.updated_at === 'string' ? row.updated_at : undefined;
+        const updatedAt = updatedAtRaw !== undefined && updatedAtRaw.trim().length > 0
+            ? updatedAtRaw
+            : new Date(0).toISOString();
+        const retryAtRaw = typeof row.retry_at === 'string' ? row.retry_at : undefined;
+        const retryAt = retryAtRaw !== undefined && retryAtRaw.trim().length > 0 ? retryAtRaw : undefined;
+        return {
+            queueName: String(row.queue_name),
+            jobId: String(row.job_id),
+            status: 'pending_recovery',
+            attempts,
+            maxAttempts,
+            createdAt: new Date().toISOString(),
+            updatedAt,
+            payload,
+            retryAt,
+        };
+    });
+};
+export default JobRecoveryDaemon;

package/src/tools/queue/JobStateTracker.d.ts

@@ -0,0 +1,140 @@
+export type JobTrackingStatus = 'pending' | 'active' | 'enqueued' | 'completed' | 'failed' | 'stalled' | 'timeout' | 'pending_recovery' | 'dead_letter' | 'manual_review' | 'delayed';
+export type JobTrackingRecord = {
+    jobId: string;
+    queueName: string;
+    status: JobTrackingStatus;
+    attempts: number;
+    maxAttempts?: number;
+    payload?: unknown;
+    result?: unknown;
+    lastError?: string;
+    lastErrorCode?: string;
+    retryAt?: string;
+    timeoutAt?: string;
+    heartbeatAt?: string;
+    expectedCompletionAt?: string;
+    workerName?: string;
+    workerInstanceId?: string;
+    workerRegion?: string;
+    workerVersion?: string;
+    recoveredAt?: string;
+    idempotencyKey?: string;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    updatedAt: string;
+};
+export type JobTrackingTransition = {
+    jobId: string;
+    queueName: string;
+    fromStatus: JobTrackingStatus | null;
+    toStatus: JobTrackingStatus;
+    reason: string;
+    timestamp: string;
+    attempts?: number;
+    error?: string;
+};
+export interface JobStateTrackerPersistenceAdapter {
+    upsertJob(record: JobTrackingRecord): Promise<void>;
+    insertTransition(transition: JobTrackingTransition): Promise<void>;
+}
+export declare const JobStateTracker: Readonly<{
+    isEnabled(): boolean;
+    enqueued(input: {
+        queueName: string;
+        jobId: string;
+        payload?: unknown;
+        attempts?: number;
+        maxAttempts?: number;
+        expectedCompletionAt?: string;
+        idempotencyKey?: string;
+    }): Promise<void>;
+    started(input: {
+        queueName: string;
+        jobId: string;
+        attempts?: number;
+        timeoutMs?: number;
+        workerName?: string;
+        workerInstanceId?: string;
+        workerRegion?: string;
+        workerVersion?: string;
+    }): Promise<void>;
+    completed(input: {
+        queueName: string;
+        jobId: string;
+        processingTimeMs?: number;
+        result?: unknown;
+    }): Promise<void>;
+    failed(input: {
+        queueName: string;
+        jobId: string;
+        attempts?: number;
+        isFinal: boolean;
+        retryAt?: string;
+        error?: unknown;
+    }): Promise<void>;
+    heartbeat(input: {
+        queueName: string;
+        jobId: string;
+        workerInstanceId?: string;
+    }): Promise<void>;
+    timedOut(input: {
+        queueName: string;
+        jobId: string;
+        reason?: string;
+        error?: unknown;
+    }): Promise<void>;
+    stalled(input: {
+        queueName: string;
+        jobId: string;
+        reason?: string;
+    }): Promise<void>;
+    pendingRecovery(input: {
+        queueName: string;
+        jobId: string;
+        attempts?: number;
+        maxAttempts?: number;
+        retryAt?: string;
+        reason?: string;
+        error?: unknown;
+    }): Promise<void>;
+    markedRecovered(input: {
+        queueName: string;
+        jobId: string;
+        reason?: string;
+        retryAt?: string;
+    }): Promise<void>;
+    handedOffToQueue(input: {
+        queueName: string;
+        jobId: string;
+        reason?: string;
+    }): Promise<void>;
+    setTerminalStatus(input: {
+        queueName: string;
+        jobId: string;
+        status: "dead_letter" | "manual_review" | "failed" | "completed";
+        reason: string;
+        error?: unknown;
+    }): Promise<void>;
+    registerPersistenceAdapter(adapter: JobStateTrackerPersistenceAdapter): void;
+    clearPersistenceAdapter(): void;
+    get(queueName: string, jobId: string): JobTrackingRecord | undefined;
+    list(options?: {
+        queueName?: string;
+        status?: JobTrackingStatus;
+        limit?: number;
+    }): JobTrackingRecord[];
+    getTransitions(options?: {
+        queueName?: string;
+        jobId?: string;
+        limit?: number;
+    }): JobTrackingTransition[];
+    listActiveOlderThan(maxAgeMs: number, queueName?: string): JobTrackingRecord[];
+    listPendingOlderThan(maxAgeMs: number, queueName?: string): JobTrackingRecord[];
+    listRecoverable(maxAgeMs: number, queueName?: string): JobTrackingRecord[];
+    listHeartbeatExpired(maxSilenceMs: number, queueName?: string): JobTrackingRecord[];
+    getSummary(queueName?: string): Record<string, number>;
+    reset(): void;
+}>;
+export default JobStateTracker;
+//# sourceMappingURL=JobStateTracker.d.ts.map

package/src/tools/queue/JobStateTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JobStateTracker.d.ts","sourceRoot":"","sources":["../../../../src/tools/queue/JobStateTracker.ts"],"names":[],"mappings":"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"}