@trigger.dev/redis-worker 4.0.0-v4-beta.21 → 4.0.0-v4-beta.23

package/dist/index.cjs

@@ -8,6 +8,8 @@ var crypto = require('crypto');
 require('@trigger.dev/core/v3/utils/flattenAttributes');
 var v3 = require('@trigger.dev/core/v3');
 var serverOnly = require('@trigger.dev/core/v3/serverOnly');
+var zod = require('zod');
+var cronParser = require('cron-parser');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -8742,7 +8744,7 @@ var require_Redis = __commonJS({
     var lodash_1 = require_lodash3();
     var Deque = require_denque();
     var debug = (0, utils_1.Debug)("redis");
-    var Redis3 = class _Redis extends Commander_1.default {
+    var Redis4 = class _Redis extends Commander_1.default {
       constructor(arg1, arg2, arg3) {
         super();
         this.status = "wait";
@@ -9305,12 +9307,12 @@ var require_Redis = __commonJS({
         }).catch(lodash_1.noop);
       }
     };
-    Redis3.Cluster = cluster_1.default;
-    Redis3.Command = Command_1.default;
-    Redis3.defaultOptions = RedisOptions_1.DEFAULT_REDIS_OPTIONS;
-    (0, applyMixin_1.default)(Redis3, events_1.EventEmitter);
-    (0, transaction_1.addTransactionSupport)(Redis3.prototype);
-    exports.default = Redis3;
+    Redis4.Cluster = cluster_1.default;
+    Redis4.Command = Command_1.default;
+    Redis4.defaultOptions = RedisOptions_1.DEFAULT_REDIS_OPTIONS;
+    (0, applyMixin_1.default)(Redis4, events_1.EventEmitter);
+    (0, transaction_1.addTransactionSupport)(Redis4.prototype);
+    exports.default = Redis4;
   }
 });
 
@@ -9563,7 +9565,8 @@ var SimpleQueue = class {
             id,
             item: parsedItem,
             job: parsedItem.job,
-            timestamp
+            timestamp,
+            availableJobs: Object.keys(this.schema)
           });
           continue;
         }
@@ -9644,8 +9647,30 @@ var SimpleQueue = class {
       throw e;
     }
   }
+  async getJob(id) {
+    const result = await this.redis.getJob(`queue`, `items`, id);
+    if (!result) {
+      return null;
+    }
+    const [_, score, serializedItem] = result;
+    const item = JSON.parse(serializedItem);
+    return {
+      id,
+      job: item.job,
+      item: item.item,
+      visibilityTimeoutMs: item.visibilityTimeoutMs,
+      attempt: item.attempt ?? 0,
+      timestamp: new Date(Number(score)),
+      deduplicationKey: item.deduplicationKey ?? void 0
+    };
+  }
   async moveToDeadLetterQueue(id, errorMessage) {
     try {
+      this.logger.debug(`SimpleQueue ${this.name}.moveToDeadLetterQueue(): moving item to DLQ`, {
+        queue: this.name,
+        id,
+        errorMessage
+      });
       const result = await this.redis.moveToDeadLetterQueue(
         `queue`,
         `items`,
@@ -9766,6 +9791,25 @@ var SimpleQueue = class {
         return dequeued
       `
     });
+    this.redis.defineCommand("getJob", {
+      numberOfKeys: 2,
+      lua: `
+        local queue = KEYS[1]
+        local items = KEYS[2]
+        local jobId = ARGV[1]
+
+        local serializedItem = redis.call('HGET', items, jobId)
+
+        if serializedItem == false then
+          return nil
+        end
+
+        -- get the score from the queue sorted set
+        local score = redis.call('ZSCORE', queue, jobId)
+
+        return { jobId, score, serializedItem }
+      `
+    });
     this.redis.defineCommand("ackItem", {
       numberOfKeys: 2,
       lua: `
@@ -11007,6 +11051,11 @@ function validateConcurrency(concurrency) {
     throw new TypeError("Expected `concurrency` to be a number from 1 and up");
   }
 }
+var CronSchema = zod.z.object({
+  cron: zod.z.string(),
+  lastTimestamp: zod.z.number().optional(),
+  timestamp: zod.z.number()
+});
 var defaultRetrySettings = {
   maxAttempts: 12,
   factor: 2,
@@ -11035,7 +11084,6 @@ var Worker = class _Worker {
     this.jobs = options.jobs;
     const { workers = 1, tasksPerWorker = 1, limit = 10 } = options.concurrency ?? {};
     this.concurrency = { workers, tasksPerWorker, limit };
-    this.limiter = pLimit(this.concurrency.limit);
     const masterQueueObservableGauge = this.meter.createObservableGauge("redis_worker.queue.size", {
       description: "The number of items in the queue",
       unit: "items",
@@ -11086,7 +11134,7 @@ var Worker = class _Worker {
   concurrency;
   shutdownTimeoutMs;
   // The p-limit limiter to control overall concurrency.
-  limiter;
+  limiters = {};
   async #updateQueueSizeMetric(observableResult) {
     const queueSize = await this.queue.size();
     observableResult.observe(queueSize, {
@@ -11100,19 +11148,30 @@ var Worker = class _Worker {
     });
   }
   async #updateConcurrencyLimitActiveMetric(observableResult) {
-    observableResult.observe(this.limiter.activeCount, {
-      worker_name: this.options.name
-    });
+    for (const [workerId, limiter] of Object.entries(this.limiters)) {
+      observableResult.observe(limiter.activeCount, {
+        worker_name: this.options.name,
+        worker_id: workerId
+      });
+    }
   }
   async #updateConcurrencyLimitPendingMetric(observableResult) {
-    observableResult.observe(this.limiter.pendingCount, {
-      worker_name: this.options.name
-    });
+    for (const [workerId, limiter] of Object.entries(this.limiters)) {
+      observableResult.observe(limiter.pendingCount, {
+        worker_name: this.options.name,
+        worker_id: workerId
+      });
+    }
   }
   start() {
     const { workers, tasksPerWorker } = this.concurrency;
+    this.logger.info("Starting worker", {
+      workers,
+      tasksPerWorker,
+      concurrency: this.concurrency
+    });
     for (let i = 0; i < workers; i++) {
-      this.workerLoops.push(this.runWorkerLoop(`worker-${nanoid(12)}`, tasksPerWorker));
+      this.workerLoops.push(this.runWorkerLoop(`worker-${nanoid(12)}`, tasksPerWorker, i, workers));
     }
     this.setupShutdownHandlers();
     this.subscriber = createRedisClient(this.options.redisOptions, {
@@ -11124,6 +11183,7 @@ var Worker = class _Worker {
       }
     });
     this.setupSubscriber();
+    this.setupCron();
     return this;
   }
   /**
@@ -11262,37 +11322,78 @@ var Worker = class _Worker {
       }
     );
   }
+  async getJob(id) {
+    return this.queue.getJob(id);
+  }
   /**
    * The main loop that each worker runs. It repeatedly polls for items,
    * processes them, and then waits before the next iteration.
    */
-  async runWorkerLoop(workerId, taskCount) {
+  async runWorkerLoop(workerId, taskCount, workerIndex, totalWorkers) {
+    const limiter = pLimit(this.concurrency.limit);
+    this.limiters[workerId] = limiter;
     const pollIntervalMs = this.options.pollIntervalMs ?? 1e3;
     const immediatePollIntervalMs = this.options.immediatePollIntervalMs ?? 100;
+    const delayBetweenWorkers = this.options.pollIntervalMs ?? 1e3;
+    const delay = delayBetweenWorkers * (totalWorkers - workerIndex);
+    await _Worker.delay(delay);
+    this.logger.info("Starting worker loop", {
+      workerIndex,
+      totalWorkers,
+      delay,
+      workerId,
+      taskCount,
+      pollIntervalMs,
+      immediatePollIntervalMs,
+      concurrencyOptions: this.concurrency
+    });
     while (!this.isShuttingDown) {
-      if (this.limiter.activeCount + this.limiter.pendingCount >= this.concurrency.limit) {
+      if (limiter.activeCount + limiter.pendingCount >= this.concurrency.limit) {
+        this.logger.debug("Worker at capacity, waiting", {
+          workerId,
+          concurrencyOptions: this.concurrency,
+          activeCount: limiter.activeCount,
+          pendingCount: limiter.pendingCount
+        });
         await _Worker.delay(pollIntervalMs);
         continue;
       }
+      const $taskCount = Math.min(
+        taskCount,
+        this.concurrency.limit - limiter.activeCount - limiter.pendingCount
+      );
       try {
         const items = await this.withHistogram(
           this.metrics.dequeueDuration,
-          this.queue.dequeue(taskCount),
+          this.queue.dequeue($taskCount),
           {
             worker_id: workerId,
-            task_count: taskCount
+            task_count: $taskCount
           }
         );
         if (items.length === 0) {
+          this.logger.debug("No items to dequeue", {
+            workerId,
+            concurrencyOptions: this.concurrency,
+            activeCount: limiter.activeCount,
+            pendingCount: limiter.pendingCount
+          });
           await _Worker.delay(pollIntervalMs);
           continue;
         }
+        this.logger.debug("Dequeued items", {
+          workerId,
+          itemCount: items.length,
+          concurrencyOptions: this.concurrency,
+          activeCount: limiter.activeCount,
+          pendingCount: limiter.pendingCount
+        });
         for (const item of items) {
-          this.limiter(() => this.processItem(item, items.length, workerId)).catch(
-            (err) => {
-              this.logger.error("Unhandled error in processItem:", { error: err, workerId, item });
-            }
-          );
+          limiter(
+            () => this.processItem(item, items.length, workerId, limiter)
+          ).catch((err) => {
+            this.logger.error("Unhandled error in processItem:", { error: err, workerId, item });
+          });
         }
       } catch (error) {
         this.logger.error("Error dequeuing items:", { name: this.options.name, error });
@@ -11301,17 +11402,22 @@ var Worker = class _Worker {
       }
       await _Worker.delay(immediatePollIntervalMs);
     }
+    this.logger.info("Worker loop finished", { workerId });
   }
   /**
    * Processes a single item.
    */
-  async processItem({ id, job, item, visibilityTimeoutMs, attempt, timestamp, deduplicationKey }, batchSize, workerId) {
+  async processItem({ id, job, item, visibilityTimeoutMs, attempt, timestamp, deduplicationKey }, batchSize, workerId, limiter) {
     const catalogItem = this.options.catalog[job];
     const handler = this.jobs[job];
     if (!handler) {
       this.logger.error(`No handler found for job type: ${job}`);
       return;
     }
+    if (!catalogItem) {
+      this.logger.error(`No catalog item found for job type: ${job}`);
+      return;
+    }
     await startSpan(
       this.tracer,
       "processItem",
@@ -11327,6 +11433,9 @@ var Worker = class _Worker {
           }
         );
         await this.queue.ack(id, deduplicationKey);
+        if (catalogItem.cron) {
+          await this.rescheduleCronJob(job, catalogItem, item);
+        }
       },
       {
         kind: SpanKind.CONSUMER,
@@ -11337,9 +11446,9 @@ var Worker = class _Worker {
           job_timestamp: timestamp.getTime(),
           job_age_in_ms: Date.now() - timestamp.getTime(),
           worker_id: workerId,
-          worker_limit_concurrency: this.limiter.concurrency,
-          worker_limit_active: this.limiter.activeCount,
-          worker_limit_pending: this.limiter.pendingCount,
+          worker_limit_concurrency: limiter.concurrency,
+          worker_limit_active: limiter.activeCount,
+          worker_limit_pending: limiter.pendingCount,
           worker_name: this.options.name,
           batch_size: batchSize
         }
@@ -11373,6 +11482,9 @@ var Worker = class _Worker {
             errorMessage
           });
           await this.queue.moveToDeadLetterQueue(id, errorMessage);
+          if (catalogItem.cron) {
+            await this.rescheduleCronJob(job, catalogItem, item);
+          }
           return;
         }
         const retryDate = new Date(Date.now() + retryDelay);
@@ -11425,6 +11537,93 @@ var Worker = class _Worker {
   static delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
+  setupCron() {
+    const cronJobs = Object.entries(this.options.catalog).filter(([_, value]) => value.cron);
+    if (cronJobs.length === 0) {
+      return;
+    }
+    this.logger.info("Setting up cron jobs", {
+      cronJobs: cronJobs.map(([job, value]) => ({
+        job,
+        cron: value.cron,
+        jitterInMs: value.jitterInMs
+      }))
+    });
+    const enqueuePromises = cronJobs.map(
+      ([job, value]) => this.enqueueCronJob(value.cron, job, value.jitterInMs)
+    );
+    Promise.allSettled(enqueuePromises).then((results) => {
+      results.forEach((result) => {
+        if (result.status === "fulfilled") {
+          this.logger.info("Enqueued cron job", { result: result.value });
+        } else {
+          this.logger.error("Failed to enqueue cron job", { reason: result.reason });
+        }
+      });
+    });
+  }
+  async enqueueCronJob(cron, job, jitter, lastTimestamp) {
+    const scheduledAt = this.calculateNextScheduledAt(cron, lastTimestamp);
+    const identifier = [job, this.timestampIdentifier(scheduledAt)].join(":");
+    const appliedJitter = typeof jitter === "number" ? Math.random() * jitter - jitter / 2 : 0;
+    const availableAt = new Date(scheduledAt.getTime() + appliedJitter);
+    const enqueued = await this.enqueueOnce({
+      id: identifier,
+      job,
+      payload: {
+        timestamp: scheduledAt.getTime(),
+        lastTimestamp: lastTimestamp?.getTime(),
+        cron
+      },
+      availableAt
+    });
+    this.logger.info("Enqueued cron job", {
+      identifier,
+      cron,
+      job,
+      scheduledAt,
+      enqueued,
+      availableAt,
+      appliedJitter,
+      jitter
+    });
+    return {
+      identifier,
+      cron,
+      job,
+      scheduledAt,
+      enqueued
+    };
+  }
+  async rescheduleCronJob(job, catalogItem, item) {
+    if (!catalogItem.cron) {
+      return;
+    }
+    return this.enqueueCronJob(
+      catalogItem.cron,
+      job,
+      catalogItem.jitterInMs,
+      new Date(item.timestamp)
+    );
+  }
+  calculateNextScheduledAt(cron, lastTimestamp) {
+    const scheduledAt = cronParser.parseExpression(cron, {
+      currentDate: lastTimestamp
+    }).next().toDate();
+    if (scheduledAt < /* @__PURE__ */ new Date()) {
+      return this.calculateNextScheduledAt(cron);
+    }
+    return scheduledAt;
+  }
+  timestampIdentifier(timestamp) {
+    const year = timestamp.getUTCFullYear();
+    const month = timestamp.getUTCMonth();
+    const day = timestamp.getUTCDate();
+    const hour = timestamp.getUTCHours();
+    const minute = timestamp.getUTCMinutes();
+    const second = timestamp.getUTCSeconds();
+    return `${year}-${month}-${day}-${hour}-${minute}-${second}`;
+  }
   setupSubscriber() {
     const channel = `${this.options.name}:redrive`;
     this.subscriber?.subscribe(channel, (err) => {
@@ -11481,6 +11680,7 @@ var Worker = class _Worker {
   }
 };
 
+exports.CronSchema = CronSchema;
 exports.SimpleQueue = SimpleQueue;
 exports.Worker = Worker;
 //# sourceMappingURL=index.cjs.map