bullmq 5.1.3 → 5.1.5

package/dist/cjs/scripts/{moveStalledJobsToWait-8.js → moveStalledJobsToWait-9.js}

@@ -11,34 +11,33 @@ const content = `--[[
       KEYS[5] 'stalled-check', (KEY)
       KEYS[6] 'meta', (KEY)
       KEYS[7] 'paused', (LIST)
-      KEYS[8] 'event stream' (STREAM)
+      KEYS[8] 'marker'
+      KEYS[9] 'event stream' (STREAM)
       ARGV[1]  Max stalled job count
       ARGV[2]  queue.toKey('')
       ARGV[3]  timestamp
       ARGV[4]  max check time
     Events:
       'stalled' with stalled job id.
-]] -- Includes
---[[
-  Move stalled jobs to wait.
-    Input:
-      stalledKey 'stalled' (SET)
-      waitKey 'wait',   (LIST)
-      activeKey 'active', (LIST)
-      failedKey 'failed', (ZSET)
-      stalledCheckKey 'stalled-check', (KEY)
-      metaKey 'meta', (KEY)
-      pausedKey 'paused', (LIST)
-      eventStreamKey 'event stream' (STREAM)
-      maxStalledJobCount  Max stalled job count
-      queueKeyPrefix  queue.toKey('')
-      timestamp  timestamp
-      maxCheckTime  max check time
-    Events:
-      'stalled' with stalled job id.
 ]]
 local rcall = redis.call
 -- Includes
+--[[
+  Function to add job in target list and add marker if needed.
+]]
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
+end
 --[[
   Function to loop in batches.
   Just a bit of warning, some commands as ZREM
@@ -200,103 +199,107 @@ local function trimEvents(metaKey, eventStreamKey)
     rcall("XTRIM", eventStreamKey, "MAXLEN", "~", 10000)
   end
 end
--- Check if we need to check for stalled jobs now.
-local function checkStalledJobs(stalledKey, waitKey, activeKey, failedKey,
-                                stalledCheckKey, metaKey, pausedKey,
-                                eventStreamKey, maxStalledJobCount,
-                                queueKeyPrefix, timestamp, maxCheckTime)
-    if rcall("EXISTS", stalledCheckKey) == 1 then return {{}, {}} end
-    rcall("SET", stalledCheckKey, timestamp, "PX", maxCheckTime)
-    -- Trim events before emiting them to avoid trimming events emitted in this script
-    trimEvents(metaKey, eventStreamKey)
-    -- Move all stalled jobs to wait
-    local stalling = rcall('SMEMBERS', stalledKey)
-    local stalled = {}
-    local failed = {}
-    if (#stalling > 0) then
-        rcall('DEL', stalledKey)
-        local MAX_STALLED_JOB_COUNT = tonumber(maxStalledJobCount)
-        -- Remove from active list
-        for i, jobId in ipairs(stalling) do
-            -- Markers in waitlist DEPRECATED in v5: Remove in v6.
-            if string.sub(jobId, 1, 2) == "0:" then
-                -- If the jobId is a delay marker ID we just remove it.
-                rcall("LREM", activeKey, 1, jobId)
-            else
-                local jobKey = queueKeyPrefix .. jobId
-                -- Check that the lock is also missing, then we can handle this job as really stalled.
-                if (rcall("EXISTS", jobKey .. ":lock") == 0) then
-                    --  Remove from the active queue.
-                    local removed = rcall("LREM", activeKey, 1, jobId)
-                    if (removed > 0) then
-                        -- If this job has been stalled too many times, such as if it crashes the worker, then fail it.
-                        local stalledCount =
-                            rcall("HINCRBY", jobKey, "stalledCounter", 1)
-                        if (stalledCount > MAX_STALLED_JOB_COUNT) then
-                            local rawOpts = rcall("HGET", jobKey, "opts")
-                            local opts = cjson.decode(rawOpts)
-                            local removeOnFailType = type(opts["removeOnFail"])
-                            rcall("ZADD", failedKey, timestamp, jobId)
-                            local failedReason =
-                                "job stalled more than allowable limit"
-                            rcall("HMSET", jobKey, "failedReason", failedReason,
-                                  "finishedOn", timestamp)
-                            rcall("XADD", eventStreamKey, "*", "event",
-                                  "failed", "jobId", jobId, 'prev', 'active',
-                                  'failedReason', failedReason)
-                            if removeOnFailType == "number" then
-                                removeJobsByMaxCount(opts["removeOnFail"],
-                                                     failedKey, queueKeyPrefix)
-                            elseif removeOnFailType == "boolean" then
-                                if opts["removeOnFail"] then
-                                    removeJob(jobId, false, queueKeyPrefix)
-                                    rcall("ZREM", failedKey, jobId)
-                                end
-                            elseif removeOnFailType ~= "nil" then
-                                local maxAge = opts["removeOnFail"]["age"]
-                                local maxCount = opts["removeOnFail"]["count"]
-                                if maxAge ~= nil then
-                                    removeJobsByMaxAge(timestamp, maxAge,
-                                                       failedKey, queueKeyPrefix)
-                                end
-                                if maxCount ~= nil and maxCount > 0 then
-                                    removeJobsByMaxCount(maxCount, failedKey,
-                                                         queueKeyPrefix)
-                                end
+local stalledKey = KEYS[1]
+local waitKey = KEYS[2]
+local activeKey = KEYS[3]
+local failedKey = KEYS[4]
+local stalledCheckKey = KEYS[5]
+local metaKey = KEYS[6]
+local pausedKey = KEYS[7]
+local markerKey = KEYS[8]
+local eventStreamKey = KEYS[9]
+local maxStalledJobCount = ARGV[1]
+local queueKeyPrefix = ARGV[2]
+local timestamp = ARGV[3]
+local maxCheckTime = ARGV[4]
+if rcall("EXISTS", stalledCheckKey) == 1 then return {{}, {}} end
+rcall("SET", stalledCheckKey, timestamp, "PX", maxCheckTime)
+-- Trim events before emiting them to avoid trimming events emitted in this script
+trimEvents(metaKey, eventStreamKey)
+-- Move all stalled jobs to wait
+local stalling = rcall('SMEMBERS', stalledKey)
+local stalled = {}
+local failed = {}
+if (#stalling > 0) then
+    rcall('DEL', stalledKey)
+    local MAX_STALLED_JOB_COUNT = tonumber(maxStalledJobCount)
+    -- Remove from active list
+    for i, jobId in ipairs(stalling) do
+        -- Markers in waitlist DEPRECATED in v5: Remove in v6.
+        if string.sub(jobId, 1, 2) == "0:" then
+            -- If the jobId is a delay marker ID we just remove it.
+            rcall("LREM", activeKey, 1, jobId)
+        else
+            local jobKey = queueKeyPrefix .. jobId
+            -- Check that the lock is also missing, then we can handle this job as really stalled.
+            if (rcall("EXISTS", jobKey .. ":lock") == 0) then
+                --  Remove from the active queue.
+                local removed = rcall("LREM", activeKey, 1, jobId)
+                if (removed > 0) then
+                    -- If this job has been stalled too many times, such as if it crashes the worker, then fail it.
+                    local stalledCount =
+                        rcall("HINCRBY", jobKey, "stalledCounter", 1)
+                    if (stalledCount > MAX_STALLED_JOB_COUNT) then
+                        local rawOpts = rcall("HGET", jobKey, "opts")
+                        local opts = cjson.decode(rawOpts)
+                        local removeOnFailType = type(opts["removeOnFail"])
+                        rcall("ZADD", failedKey, timestamp, jobId)
+                        local failedReason =
+                            "job stalled more than allowable limit"
+                        rcall("HMSET", jobKey, "failedReason", failedReason,
+                              "finishedOn", timestamp)
+                        rcall("XADD", eventStreamKey, "*", "event",
+                              "failed", "jobId", jobId, 'prev', 'active',
+                              'failedReason', failedReason)
+                        if removeOnFailType == "number" then
+                            removeJobsByMaxCount(opts["removeOnFail"],
+                                                  failedKey, queueKeyPrefix)
+                        elseif removeOnFailType == "boolean" then
+                            if opts["removeOnFail"] then
+                                removeJob(jobId, false, queueKeyPrefix)
+                                rcall("ZREM", failedKey, jobId)
+                            end
+                        elseif removeOnFailType ~= "nil" then
+                            local maxAge = opts["removeOnFail"]["age"]
+                            local maxCount = opts["removeOnFail"]["count"]
+                            if maxAge ~= nil then
+                                removeJobsByMaxAge(timestamp, maxAge,
+                                                    failedKey, queueKeyPrefix)
+                            end
+                            if maxCount ~= nil and maxCount > 0 then
+                                removeJobsByMaxCount(maxCount, failedKey,
+                                                      queueKeyPrefix)
                             end
-                            table.insert(failed, jobId)
-                        else
-                            local target =
-                                getTargetQueueList(metaKey, waitKey, pausedKey)
-                            -- Move the job back to the wait queue, to immediately be picked up by a waiting worker.
-                            rcall("RPUSH", target, jobId)
-                            rcall("XADD", eventStreamKey, "*", "event",
-                                  "waiting", "jobId", jobId, 'prev', 'active')
-                            -- Emit the stalled event
-                            rcall("XADD", eventStreamKey, "*", "event",
-                                  "stalled", "jobId", jobId)
-                            table.insert(stalled, jobId)
                         end
+                        table.insert(failed, jobId)
+                    else
+                        local target, isPaused=
+                            getTargetQueueList(metaKey, waitKey, pausedKey)
+                        -- Move the job back to the wait queue, to immediately be picked up by a waiting worker.
+                        addJobInTargetList(target, markerKey, "RPUSH", isPaused, jobId)
+                        rcall("XADD", eventStreamKey, "*", "event",
+                              "waiting", "jobId", jobId, 'prev', 'active')
+                        -- Emit the stalled event
+                        rcall("XADD", eventStreamKey, "*", "event",
+                              "stalled", "jobId", jobId)
+                        table.insert(stalled, jobId)
                     end
                 end
             end
         end
     end
-    -- Mark potentially stalled jobs
-    local active = rcall('LRANGE', activeKey, 0, -1)
-    if (#active > 0) then
-        for from, to in batches(#active, 7000) do
-            rcall('SADD', stalledKey, unpack(active, from, to))
-        end
+end
+-- Mark potentially stalled jobs
+local active = rcall('LRANGE', activeKey, 0, -1)
+if (#active > 0) then
+    for from, to in batches(#active, 7000) do
+        rcall('SADD', stalledKey, unpack(active, from, to))
     end
-    return {failed, stalled}
 end
-return checkStalledJobs(KEYS[1], KEYS[2], KEYS[3], KEYS[4], KEYS[5], KEYS[6],
-                        KEYS[7], KEYS[8], ARGV[1], ARGV[2], ARGV[3], ARGV[4])
-`;
+return {failed, stalled}`;
 exports.moveStalledJobsToWait = {
     name: 'moveStalledJobsToWait',
     content,
-    keys: 8,
+    keys: 9,
 };
-//# sourceMappingURL=moveStalledJobsToWait-8.js.map
+//# sourceMappingURL=moveStalledJobsToWait-9.js.map

package/dist/cjs/scripts/{moveStalledJobsToWait-8.js.map → moveStalledJobsToWait-9.js.map}

@@ -1 +1 @@
-{"version":3,"file":"moveStalledJobsToWait-8.js","sourceRoot":"","sources":["../../../src/scripts/moveStalledJobsToWait-8.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoSf,CAAC;AACW,QAAA,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
+{"version":3,"file":"moveStalledJobsToWait-9.js","sourceRoot":"","sources":["../../../src/scripts/moveStalledJobsToWait-9.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAuSS,CAAC;AACb,QAAA,qBAAqB,GAAG;IACnC,IAAI,EAAE,uBAAuB;IAC7B,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}

package/dist/cjs/scripts/moveToActive-11.js

@@ -33,6 +33,7 @@ const content = `--[[
 local rcall = redis.call
 local waitKey = KEYS[1]
 local activeKey = KEYS[2]
+local eventStreamKey = KEYS[4]
 local rateLimiterKey = KEYS[6]
 local delayedKey = KEYS[7]
 local opts = cmsgpack.unpack(ARGV[3])
@@ -91,50 +92,15 @@ end
 --[[
   Function to move job from wait state to active.
   Input:
-    keys[1] wait key
-    keys[2] active key
-    keys[3] prioritized key
-    keys[4] stream events key
-    keys[5] stalled key
-    -- Rate limiting
-    keys[6] rate limiter key
-    keys[7] delayed key
-    keys[8] paused key
-    keys[9] meta key
-    keys[10] pc priority counter
     opts - token - lock token
     opts - lockDuration
     opts - limiter
 ]]
--- Includes
---[[
-  Function to push back job considering priority in front of same prioritized jobs.
-]]
-local function pushBackJobWithPriority(prioritizedKey, priority, jobId)
-  -- in order to put it at front of same prioritized jobs
-  -- we consider prioritized counter as 0
-  local score = priority * 0x100000000
-  rcall("ZADD", prioritizedKey, score, jobId)
-end
-local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, processedOn,
-    maxJobs, expireTime, opts)
+local function prepareJobForProcessing(keyPrefix, rateLimiterKey, eventStreamKey,
+    jobId, processedOn, maxJobs, opts)
   local jobKey = keyPrefix .. jobId
   -- Check if we need to perform rate limiting.
   if maxJobs then
-    local rateLimiterKey = keys[6];
-    -- check if we exceeded rate limit, we need to remove the job and return expireTime
-    if expireTime > 0 then
-      -- remove from active queue and add back to the wait list
-      rcall("LREM", keys[2], 1, jobId)
-      local priority = tonumber(rcall("HGET", jobKey, "priority")) or 0
-      if priority == 0 then
-        rcall("RPUSH", targetKey, jobId)
-      else
-        pushBackJobWithPriority(keys[3], priority, jobId)
-      end
-      -- Return when we can process more jobs
-      return {0, 0, expireTime, 0}
-    end
     local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
     if jobCounter == 1 then
       local limiterDuration = opts['limiter'] and opts['limiter']['duration']
@@ -147,7 +113,7 @@ local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, proces
   if opts['token'] ~= "0" then
     rcall("SET", lockKey, opts['token'], "PX", opts['lockDuration'])
   end
-  rcall("XADD", keys[4], "*", "event", "active", "jobId", jobId, "prev", "waiting")
+  rcall("XADD", eventStreamKey, "*", "event", "active", "jobId", jobId, "prev", "waiting")
   rcall("HSET", jobKey, "processedOn", processedOn)
   rcall("HINCRBY", jobKey, "ats", 1)
   return {rcall("HGETALL", jobKey), jobId, 0, 0} -- get job data
@@ -159,16 +125,31 @@ end
       'waiting'
 ]]
 -- Includes
+--[[
+  Function to add job in target list and add marker if needed.
+]]
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
+end
 --[[
   Function to add job considering priority.
 ]]
+-- Includes
 local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
   local prioCounter = rcall("INCR", priorityCounterKey)
   local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
   rcall("ZADD", prioritizedKey, score, jobId)
-  if not isPaused then
-    rcall("ZADD", markerKey, 0, "0")
-  end
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 -- Try to get as much as 1000 jobs at once
 local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedKey,
@@ -182,10 +163,7 @@ local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedK
                 tonumber(rcall("HGET", jobKey, "priority")) or 0
             if priority == 0 then
                 -- LIFO or FIFO
-                rcall("LPUSH", targetKey, jobId)
-                if not isPaused then
-                    rcall("ZADD", markerKey, 0, "0")
-                end
+                addJobInTargetList(targetKey, markerKey, "LPUSH", isPaused, jobId)
             else
                 addJobWithPriority(markerKey, prioritizedKey, priority,
                   jobId, priorityCounterKey, isPaused)
@@ -200,7 +178,7 @@ end
 local target, paused = getTargetQueueList(KEYS[9], waitKey, KEYS[8])
 -- Check if there are delayed jobs that we can move to wait.
 local markerKey = KEYS[11]
-promoteDelayedJobs(delayedKey, markerKey, target, KEYS[3], KEYS[4], ARGV[1],
+promoteDelayedJobs(delayedKey, markerKey, target, KEYS[3], eventStreamKey, ARGV[1],
                    ARGV[2], KEYS[10], paused)
 local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
 local expireTime = getRateLimitTTL(maxJobs, rateLimiterKey)
@@ -216,13 +194,13 @@ if jobId and string.sub(jobId, 1, 2) == "0:" then
     jobId = rcall("RPOPLPUSH", waitKey, activeKey)
 end
 if jobId then
-    return prepareJobForProcessing(KEYS, ARGV[1], target, jobId, ARGV[2],
-                                   maxJobs, expireTime, opts)
+    return prepareJobForProcessing(ARGV[1], rateLimiterKey, eventStreamKey, jobId, ARGV[2],
+                                   maxJobs, opts)
 else
     jobId = moveJobFromPriorityToActive(KEYS[3], activeKey, KEYS[10])
     if jobId then
-        return prepareJobForProcessing(KEYS, ARGV[1], target, jobId, ARGV[2],
-                                       maxJobs, expireTime, opts)
+        return prepareJobForProcessing(ARGV[1], rateLimiterKey, eventStreamKey, jobId, ARGV[2],
+                                       maxJobs, opts)
     end
 end
 -- Return the timestamp for the next delayed job if any.

package/dist/cjs/scripts/moveToActive-11.js.map

@@ -1 +1 @@
-{"version":3,"file":"moveToActive-11.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-11.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoOf,CAAC;AACW,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
+{"version":3,"file":"moveToActive-11.js","sourceRoot":"","sources":["../../../src/scripts/moveToActive-11.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Mf,CAAC;AACW,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}

package/dist/cjs/scripts/moveToDelayed-7.js

@@ -29,7 +29,7 @@ local rcall = redis.call
 -- Includes
 --[[
   Add delay marker if needed.
-]] 
+]]
 -- Includes
 --[[
   Function to return the next delayed job timestamp.

package/dist/cjs/scripts/moveToFinished-14.js

@@ -116,6 +116,17 @@ local function getNextDelayedTimestamp(delayedKey)
     return nextTimestamp
   end
 end
+--[[
+  Function to check for the meta.paused key to decide if we are paused or not
+  (since an empty list and !EXISTS are not really the same).
+]]
+local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
+  if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
+    return waitKey, false
+  else
+    return pausedKey, true
+  end
+end
 --[[
   Function to move job from prioritized state to active.
 ]]
@@ -131,50 +142,15 @@ end
 --[[
   Function to move job from wait state to active.
   Input:
-    keys[1] wait key
-    keys[2] active key
-    keys[3] prioritized key
-    keys[4] stream events key
-    keys[5] stalled key
-    -- Rate limiting
-    keys[6] rate limiter key
-    keys[7] delayed key
-    keys[8] paused key
-    keys[9] meta key
-    keys[10] pc priority counter
     opts - token - lock token
     opts - lockDuration
     opts - limiter
 ]]
--- Includes
---[[
-  Function to push back job considering priority in front of same prioritized jobs.
-]]
-local function pushBackJobWithPriority(prioritizedKey, priority, jobId)
-  -- in order to put it at front of same prioritized jobs
-  -- we consider prioritized counter as 0
-  local score = priority * 0x100000000
-  rcall("ZADD", prioritizedKey, score, jobId)
-end
-local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, processedOn,
-    maxJobs, expireTime, opts)
+local function prepareJobForProcessing(keyPrefix, rateLimiterKey, eventStreamKey,
+    jobId, processedOn, maxJobs, opts)
   local jobKey = keyPrefix .. jobId
   -- Check if we need to perform rate limiting.
   if maxJobs then
-    local rateLimiterKey = keys[6];
-    -- check if we exceeded rate limit, we need to remove the job and return expireTime
-    if expireTime > 0 then
-      -- remove from active queue and add back to the wait list
-      rcall("LREM", keys[2], 1, jobId)
-      local priority = tonumber(rcall("HGET", jobKey, "priority")) or 0
-      if priority == 0 then
-        rcall("RPUSH", targetKey, jobId)
-      else
-        pushBackJobWithPriority(keys[3], priority, jobId)
-      end
-      -- Return when we can process more jobs
-      return {0, 0, expireTime, 0}
-    end
     local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
     if jobCounter == 1 then
       local limiterDuration = opts['limiter'] and opts['limiter']['duration']
@@ -187,7 +163,7 @@ local function prepareJobForProcessing(keys, keyPrefix, targetKey, jobId, proces
   if opts['token'] ~= "0" then
     rcall("SET", lockKey, opts['token'], "PX", opts['lockDuration'])
   end
-  rcall("XADD", keys[4], "*", "event", "active", "jobId", jobId, "prev", "waiting")
+  rcall("XADD", eventStreamKey, "*", "event", "active", "jobId", jobId, "prev", "waiting")
   rcall("HSET", jobKey, "processedOn", processedOn)
   rcall("HINCRBY", jobKey, "ats", 1)
   return {rcall("HGETALL", jobKey), jobId, 0, 0} -- get job data
@@ -202,7 +178,7 @@ end
 -- Includes
 --[[
   Add delay marker if needed.
-]] 
+]]
 -- Includes
 local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     local nextTimestamp = getNextDelayedTimestamp(delayedKey)
@@ -213,33 +189,37 @@ local function addDelayMarkerIfNeeded(markerKey, delayedKey)
     end
 end
 --[[
-  Function to check for the meta.paused key to decide if we are paused or not
-  (since an empty list and !EXISTS are not really the same).
+  Function to add job in target list and add marker if needed.
 ]]
-local function isQueuePaused(queueMetaKey)
-    return rcall("HEXISTS", queueMetaKey, "paused") == 1
+-- Includes
+--[[
+  Add marker if needed when a job is available.
+]]
+local function addBaseMarkerIfNeeded(markerKey, isPaused)
+  if not isPaused then
+    rcall("ZADD", markerKey, 0, "0")
+  end  
+end
+local function addJobInTargetList(targetKey, markerKey, pushCmd, isPaused, jobId)
+  rcall(pushCmd, targetKey, jobId)
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 --[[
   Function to add job considering priority.
 ]]
+-- Includes
 local function addJobWithPriority(markerKey, prioritizedKey, priority, jobId, priorityCounterKey, isPaused)
   local prioCounter = rcall("INCR", priorityCounterKey)
   local score = priority * 0x100000000 + bit.band(prioCounter, 0xffffffffffff)
   rcall("ZADD", prioritizedKey, score, jobId)
-  if not isPaused then
-    rcall("ZADD", markerKey, 0, "0")
-  end
+  addBaseMarkerIfNeeded(markerKey, isPaused)
 end
 --[[
   Function to check for the meta.paused key to decide if we are paused or not
   (since an empty list and !EXISTS are not really the same).
 ]]
-local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
-  if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
-    return waitKey, false
-  else
-    return pausedKey, true
-  end
+local function isQueuePaused(queueMetaKey)
+    return rcall("HEXISTS", queueMetaKey, "paused") == 1
 end
 local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
                                         parentKey, parentId, timestamp)
@@ -264,11 +244,10 @@ local function moveParentToWaitIfNeeded(parentQueueKey, parentDependenciesKey,
             addDelayMarkerIfNeeded(parentMarkerKey, parentDelayedKey)
         else
             if priority == 0 then
-                local parentTarget, _paused =
+                local parentTarget, isParentPaused =
                     getTargetQueueList(parentMetaKey, parentWaitKey,
                                        parentPausedKey)
-                rcall("RPUSH", parentTarget, parentId)
-                rcall("ZADD", parentMarkerKey, 0, "0")
+                addJobInTargetList(parentTarget, parentMarkerKey, "RPUSH", isParentPaused, parentId)
             else
                 local isPaused = isQueuePaused(parentMetaKey)
                 addJobWithPriority(parentMarkerKey,
@@ -328,10 +307,7 @@ local function promoteDelayedJobs(delayedKey, markerKey, targetKey, prioritizedK
                 tonumber(rcall("HGET", jobKey, "priority")) or 0
             if priority == 0 then
                 -- LIFO or FIFO
-                rcall("LPUSH", targetKey, jobId)
-                if not isPaused then
-                    rcall("ZADD", markerKey, 0, "0")
-                end
+                addJobInTargetList(targetKey, markerKey, "LPUSH", isPaused, jobId)
             else
                 addJobWithPriority(markerKey, prioritizedKey, priority,
                   jobId, priorityCounterKey, isPaused)
@@ -543,9 +519,10 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     -- Remove from active list (if not active we shall return error)
     local numRemovedElements = rcall("LREM", KEYS[2], -1, jobId)
     if (numRemovedElements < 1) then return -3 end
+    local eventStreamKey = KEYS[4]
     local metaKey = KEYS[9]
     -- Trim events before emiting them to avoid trimming events emitted in this script
-    trimEvents(metaKey, KEYS[4])
+    trimEvents(metaKey, eventStreamKey)
     -- If job has a parent we need to
     -- 1) remove this job id from parents dependencies
     -- 2) move the job Id to parent "processed" set
@@ -599,11 +576,11 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
             removeParentDependencyKey(jobIdKey, false, parentKey)
         end
     end
-    rcall("XADD", KEYS[4], "*", "event", ARGV[5], "jobId", jobId, ARGV[3],
+    rcall("XADD", eventStreamKey, "*", "event", ARGV[5], "jobId", jobId, ARGV[3],
           ARGV[4])
     if ARGV[5] == "failed" then
         if tonumber(attemptsMade) >= tonumber(attempts) then
-            rcall("XADD", KEYS[4], "*", "event", "retries-exhausted", "jobId",
+            rcall("XADD", eventStreamKey, "*", "event", "retries-exhausted", "jobId",
                   jobId, "attemptsMade", attemptsMade)
         end
     end
@@ -616,7 +593,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
     if (ARGV[6] == "1") then
         local target, paused = getTargetQueueList(metaKey, KEYS[1], KEYS[8])
         -- Check if there are delayed jobs that can be promoted
-        promoteDelayedJobs(KEYS[7], KEYS[14], target, KEYS[3], KEYS[4], ARGV[7],
+        promoteDelayedJobs(KEYS[7], KEYS[14], target, KEYS[3], eventStreamKey, ARGV[7],
                            timestamp, KEYS[10], paused)
         local maxJobs = tonumber(opts['limiter'] and opts['limiter']['max'])
         -- Check if we are rate limited first.
@@ -634,20 +611,20 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
                 if jobId == "0:0" then
                     jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2],
                                                         KEYS[10])
-                    return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
+                    return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
                                                    timestamp, maxJobs,
-                                                   expireTime, opts)
+                                                   opts)
                 end
             else
-                return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
-                                               timestamp, maxJobs, expireTime,
+                return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
+                                               timestamp, maxJobs,
                                                opts)
             end
         else
             jobId = moveJobFromPriorityToActive(KEYS[3], KEYS[2], KEYS[10])
             if jobId then
-                return prepareJobForProcessing(KEYS, ARGV[7], target, jobId,
-                                               timestamp, maxJobs, expireTime,
+                return prepareJobForProcessing(ARGV[7], KEYS[6], eventStreamKey, jobId,
+                                               timestamp, maxJobs,
                                                opts)
             end
         end
@@ -665,7 +642,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
         if activeLen == 0 then
             local prioritizedLen = rcall("ZCARD", KEYS[3])
             if prioritizedLen == 0 then
-                rcall("XADD", KEYS[4], "*", "event", "drained")
+                rcall("XADD", eventStreamKey, "*", "event", "drained")
             end
         end
     end