@trigger.dev/redis-worker 4.3.3 → 4.4.0

package/dist/index.cjs

@@ -11807,6 +11807,24 @@ var ConcurrencyManager = class {
     }
     await pipeline.exec();
   }
+  /**
+   * Release concurrency slots for multiple messages in a single pipeline.
+   * More efficient than calling release() multiple times.
+   */
+  async releaseBatch(messages) {
+    if (messages.length === 0) {
+      return;
+    }
+    const pipeline = this.redis.pipeline();
+    for (const { queue, messageId } of messages) {
+      for (const group of this.groups) {
+        const groupId = group.extractGroupId(queue);
+        const key = this.keys.concurrencyKey(group.name, groupId);
+        pipeline.srem(key, messageId);
+      }
+    }
+    await pipeline.exec();
+  }
   /**
    * Get current concurrency for a specific group.
    */
@@ -12901,7 +12919,7 @@ var VisibilityManager = class {
    *
    * @param shardId - The shard to check
    * @param getQueueKeys - Function to get queue keys for a queue ID
-   * @returns Number of messages reclaimed
+   * @returns Array of reclaimed message info for concurrency release
    */
   async reclaimTimedOut(shardId, getQueueKeys) {
     const inflightKey = this.keys.inflightKey(shardId);
@@ -12917,17 +12935,25 @@ var VisibilityManager = class {
       100
       // Process in batches
     );
-    let reclaimed = 0;
+    const reclaimedMessages = [];
     for (let i = 0; i < timedOut.length; i += 2) {
       const member = timedOut[i];
-      const originalScore = timedOut[i + 1];
-      if (!member || !originalScore) {
+      const _deadlineScore = timedOut[i + 1];
+      if (!member || !_deadlineScore) {
         continue;
       }
       const { messageId, queueId } = this.#parseMember(member);
       const { queueKey, queueItemsKey, masterQueueKey } = getQueueKeys(queueId);
       try {
-        const score = parseFloat(originalScore) || now;
+        const dataJson = await this.redis.hget(inflightDataKey, messageId);
+        let storedMessage = null;
+        if (dataJson) {
+          try {
+            storedMessage = JSON.parse(dataJson);
+          } catch {
+          }
+        }
+        const score = storedMessage?.timestamp ?? now;
         await this.redis.releaseMessage(
           inflightKey,
           inflightDataKey,
@@ -12939,11 +12965,29 @@ var VisibilityManager = class {
           score.toString(),
           queueId
         );
-        reclaimed++;
+        if (storedMessage) {
+          reclaimedMessages.push({
+            messageId,
+            queueId,
+            tenantId: storedMessage.tenantId,
+            metadata: storedMessage.metadata
+          });
+        } else {
+          this.logger.error("Missing or corrupted message data during reclaim, using fallback", {
+            messageId,
+            queueId
+          });
+          reclaimedMessages.push({
+            messageId,
+            queueId,
+            tenantId: this.keys.extractTenantId(queueId),
+            metadata: {}
+          });
+        }
         this.logger.debug("Reclaimed timed-out message", {
           messageId,
           queueId,
-          originalScore
+          deadline: _deadlineScore
         });
       } catch (error) {
         this.logger.error("Failed to reclaim message", {
@@ -12953,7 +12997,7 @@ var VisibilityManager = class {
         });
       }
     }
-    return reclaimed;
+    return reclaimedMessages;
   }
   /**
    * Get all in-flight messages for a shard.
@@ -15356,12 +15400,31 @@ var FairQueue = class {
   async #reclaimTimedOutMessages() {
     let totalReclaimed = 0;
     for (let shardId = 0; shardId < this.shardCount; shardId++) {
-      const reclaimed = await this.visibilityManager.reclaimTimedOut(shardId, (queueId) => ({
+      const reclaimedMessages = await this.visibilityManager.reclaimTimedOut(shardId, (queueId) => ({
         queueKey: this.keys.queueKey(queueId),
         queueItemsKey: this.keys.queueItemsKey(queueId),
         masterQueueKey: this.keys.masterQueueKey(this.masterQueue.getShardForQueue(queueId))
       }));
-      totalReclaimed += reclaimed;
+      if (this.concurrencyManager && reclaimedMessages.length > 0) {
+        try {
+          await this.concurrencyManager.releaseBatch(
+            reclaimedMessages.map((msg) => ({
+              queue: {
+                id: msg.queueId,
+                tenantId: msg.tenantId,
+                metadata: msg.metadata ?? {}
+              },
+              messageId: msg.messageId
+            }))
+          );
+        } catch (error) {
+          this.logger.error("Failed to release concurrency for reclaimed messages", {
+            count: reclaimedMessages.length,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      totalReclaimed += reclaimedMessages.length;
     }
     if (totalReclaimed > 0) {
       this.logger.info("Reclaimed timed-out messages", { count: totalReclaimed });