cloudtasker 0.12.rc4 → 0.12.rc9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21f0b0582c4e3b2f54cae9a7086da5a4c62f238d3f4fdaf54d78bccd7e27eff2
-  data.tar.gz: 6811ae33e4d082fafa62bb0f8021bb0cf6f36e63aa50d1683f409c3176f8a10f
+  metadata.gz: 50cd6021ad7511d7b5b385a6086eb315d9381a4f43909a6e1e9a0defbc679ea4
+  data.tar.gz: dc16cc1330b14b46a5d6ade9f9c171981fd3aef5b3db67dd474e29548acc177f
 SHA512:
-  metadata.gz: e155f136b3da0480e0644d883f275a013bd4694517d880c18a68527b16940362ee07caa1d3f8ebd303de6078fee565cf7088b425a389f0be53ee847ead91e678
-  data.tar.gz: f682af3f433e48739b0a631e593d285fe5854e789e08f93bbd2670eb08474f6d5a3dd12019f428ff596ef3c5a67b384b36d22dcd786d2c20f827669b92454b2b
+  metadata.gz: 30feac9331b9e8113e71af6c44a20d2f47fcbd41652a0d345ab8808d272bd14271ebb4a98711e42b238f6202fa8023a37c543e0f4ec7d9f9f7a46cc2732d96aa
+  data.tar.gz: 9b70a3c0733b2c510fafe48232c65bb79f5ad4da6b90fbcff86c0736fee590fab5f89846df9c41855dc7084460425660ee42799975975775b2239b9b8997171a

data/.rubocop.yml

@@ -6,13 +6,13 @@ AllCops:
     - 'vendor/**/*'
 
 Metrics/ClassLength:
-  Max: 150
+  Max: 200
 
 Metrics/ModuleLength:
   Max: 150
 
 Metrics/AbcSize:
-  Max: 20
+  Max: 25
   Exclude:
     - 'spec/support/*'
 

data/CHANGELOG.md

@@ -1,15 +1,22 @@
 # Changelog
 
-## Latest RC [v0.12.rc4](https://github.com/keypup-io/cloudtasker/tree/v0.12.rc4) (2021-03-29)
+## Latest RC [v0.12.rc8](https://github.com/keypup-io/cloudtasker/tree/v0.12.rc8) (2021-04-06)
 
-[Full Changelog](https://github.com/keypup-io/cloudtasker/compare/v0.11.0...v0.12.rc4)
+[Full Changelog](https://github.com/keypup-io/cloudtasker/compare/v0.11.0...v0.12.rc8)
 
 **Improvements:**
 - ActiveJob: do not double log errors (ActiveJob has its own error logging)
+- Batch callbacks: Retry jobs when completion callback fails
+- Batch state: use native Redis hashes to store batch state instead of a serialized hash in a string key
+- Batch progress: restrict calculation to direct children by default. Allow depth to be specified. Calculating progress using all tree jobs created significant delays on large batches.
+- Batch redis usage: cleanup batches as they get completed or become dead to avoid excessive redis usage with large batches.
+- Configuration: allow configuration of Cloud Tasks `dispatch deadline` at global and worker level
+- Cron jobs: Use Redis Sets instead of key pattern matching for resource listing
 - Error logging: Use worker logger so as to include context (job args etc.)
 - Error logging: Do not log exception and stack trace separately, combine them instead.
-- Batch callbacks: Retry jobs when completion callback fails
-- Redis: Use Redis Sets instead of key pattern matching for listing methods (Cron jobs and Local Server)
+- Local server: Use Redis Sets instead of key pattern matching for resource listing
+- Worker: raise DeadWorkerError instead of MissingWorkerArgumentsError when arguments are missing. This is more consistent with what middlewares expect.
+- Worker redis usage: delete redis payload storage once the job is successful or dead instead of expiring the key.
 
 **Fixed bugs:**
 - Retries: Enforce job retry limit on job processing. There was an edge case where jobs could be retried indefinitely on batch callback errors.

data/README.md

@@ -37,6 +37,7 @@ A local processing server is also available for development. This local server p
     1. [HTTP Error codes](#http-error-codes)
     2. [Error callbacks](#error-callbacks)
     3. [Max retries](#max-retries)
+    4. [Dispatch deadline](#dispatch-deadline)
 10. [Testing](#testing)
     1. [Test helper setup](#test-helper-setup)
     2. [In-memory queues](#in-memory-queues)
@@ -351,6 +352,23 @@ Cloudtasker.configure do |config|
   #
   # Store all job payloads in Redis exceeding 50 KB:
   # config.store_payloads_in_redis = 50
+
+  #
+  # Specify the dispatch deadline for jobs in Cloud Tasks, in seconds.
+  # Jobs taking longer will be retried by Cloud Tasks, even if they eventually
+  # complete on the server side.
+  #
+  # Note that this option is applied when jobs are enqueued job. Changing this value
+  # will not impact already enqueued jobs.
+  #
+  # This option can also be configured on a per worker basis via
+  # the cloudtasker_options directive.
+  #
+  # Supported since: v0.12.rc8
+  #
+  # Default: 600 seconds (10 minutes)
+  #
+  # config.dispatch_deadline = 600
 end
 ```
 
@@ -721,6 +739,48 @@ class SomeErrorWorker
 end
 ```
 
+### Dispatch deadline
+**Supported since**: `0.12.rc8`  
+
+By default Cloud Tasks will automatically timeout your jobs after 10 minutes, independently of your server HTTP timeout configuration.
+
+You can modify the dispatch deadline for jobs at a global level or on a per job basis.
+
+E.g. Set the default dispatch deadline to 20 minutes.
+```ruby
+# config/initializers/cloudtasker.rb
+
+Cloudtasker.configure do |config|
+  #
+  # Specify the dispatch deadline for jobs in Cloud Tasks, in seconds. 
+  # Jobs taking longer will be retried by Cloud Tasks, even if they eventually
+  # complete on the server side.
+  #
+  # Note that this option is applied when jobs are enqueued job. Changing this value
+  # will not impact already enqueued jobs.
+  #
+  # Default: 600 (10 minutes)
+  #
+  config.dispatch_deadline = 20 * 60 # 20 minutes
+end
+```
+
+E.g. Set a dispatch deadline of 5 minutes on a specific worker
+```ruby
+# app/workers/some_error_worker.rb
+
+class SomeFasterWorker
+  include Cloudtasker::Worker
+
+  # This will override the global setting
+  cloudtasker_options dispatch_deadline: 5 * 60
+
+  def perform
+    # ... do things ...
+  end
+end
+```
+
 ## Testing
 Cloudtasker provides several options to test your workers.
 

data/app/controllers/cloudtasker/worker_controller.rb

@@ -19,7 +19,7 @@ module Cloudtasker
       # Process payload
       WorkerHandler.execute_from_payload!(payload)
       head :no_content
-    rescue DeadWorkerError, MissingWorkerArgumentsError
+    rescue DeadWorkerError
       # 205: job will NOT be retried
       head :reset_content
     rescue InvalidWorkerError

data/docs/BATCH_JOBS.md

@@ -84,8 +84,29 @@ You can access progression statistics in callback using `batch.progress`. See th
 E.g.
 ```ruby
 def on_batch_node_complete(_child_job)
-  logger.info("Total: #{batch.progress.total}")
-  logger.info("Completed: #{batch.progress.completed}")
-  logger.info("Progress: #{batch.progress.percent.to_i}%")
+  progress = batch.progress
+  logger.info("Total: #{progress.total}")
+  logger.info("Completed: #{progress.completed}")
+  logger.info("Progress: #{progress.percent.to_i}%")
+end
+```
+
+**Since:** `v0.12.rc5`  
+By default the `progress` method only considers the direct child jobs to evaluate the batch progress. You can pass `depth: somenumber` to the `progress` method to calculate the actual batch progress in a more granular way. Be careful however that this method recursively calculates progress on the sub-batches and is therefore expensive.
+
+E.g.
+```ruby
+def on_batch_node_complete(_child_job)
+  # Considers the children for batch progress calculation
+  progress_0 = batch.progress # same as batch.progress(depth: 0)
+
+  # Considers the children and grand-children for batch progress calculation
+  progress_1 = batch.progress(depth: 1)
+
+  # Considers the children, grand-children and grand-grand-children for batch progress calculation
+  progress_2 = batch.progress(depth: 3)
+
+  logger.info("Progress: #{progress_1.percent.to_i}%")
+  logger.info("Progress: #{progress_2.percent.to_i}%")
 end
 ```

data/lib/cloudtasker/backend/memory_task.rb

@@ -113,7 +113,7 @@ module Cloudtasker
       # @param [Hash] http_request The HTTP request content.
       # @param [Integer] schedule_time When to run the task (Unix timestamp)
       #
-      def initialize(id:, http_request:, schedule_time: nil, queue: nil, job_retries: 0)
+      def initialize(id:, http_request:, schedule_time: nil, queue: nil, job_retries: 0, **_xargs)
         @id = id
         @http_request = http_request
         @schedule_time = Time.at(schedule_time || 0)

data/lib/cloudtasker/backend/redis_task.rb

@@ -7,7 +7,7 @@ module Cloudtasker
   module Backend
     # Manage local tasks pushed to Redis
     class RedisTask
-      attr_reader :id, :http_request, :schedule_time, :retries, :queue
+      attr_reader :id, :http_request, :schedule_time, :retries, :queue, :dispatch_deadline
 
       RETRY_INTERVAL = 20 # seconds
 
@@ -123,13 +123,15 @@ module Cloudtasker
       # @param [Hash] http_request The HTTP request content.
       # @param [Integer] schedule_time When to run the task (Unix timestamp)
       # @param [Integer] retries The number of times the job failed.
+      # @param [Integer] dispatch_deadline The dispatch_deadline in seconds.
       #
-      def initialize(id:, http_request:, schedule_time: nil, retries: 0, queue: nil)
+      def initialize(id:, http_request:, schedule_time: nil, retries: 0, queue: nil, dispatch_deadline: nil)
         @id = id
         @http_request = http_request
         @schedule_time = Time.at(schedule_time || 0)
         @retries = retries || 0
-        @queue = queue || Cloudtasker::Config::DEFAULT_JOB_QUEUE
+        @queue = queue || Config::DEFAULT_JOB_QUEUE
+        @dispatch_deadline = dispatch_deadline || Config::DEFAULT_DISPATCH_DEADLINE
       end
 
       #
@@ -152,7 +154,8 @@ module Cloudtasker
           http_request: http_request,
           schedule_time: schedule_time.to_i,
           retries: retries,
-          queue: queue
+          queue: queue,
+          dispatch_deadline: dispatch_deadline
         }
       end
 
@@ -176,7 +179,8 @@ module Cloudtasker
           retries: is_error ? retries + 1 : retries,
           http_request: http_request,
           schedule_time: (Time.now + interval).to_i,
-          queue: queue
+          queue: queue,
+          dispatch_deadline: dispatch_deadline
         )
         redis.sadd(self.class.key, id)
       end
@@ -207,6 +211,13 @@ module Cloudtasker
         end
 
         resp
+      rescue Net::ReadTimeout
+        retry_later(RETRY_INTERVAL)
+        Cloudtasker.logger.info(
+          format_log_message(
+            "Task deadline exceeded (#{dispatch_deadline}s) - Retry in #{RETRY_INTERVAL} seconds..."
+          )
+        )
       end
 
       #
@@ -242,7 +253,7 @@ module Cloudtasker
         @http_client ||=
           begin
             uri = URI(http_request[:url])
-            Net::HTTP.new(uri.host, uri.port).tap { |e| e.read_timeout = 60 * 10 }
+            Net::HTTP.new(uri.host, uri.port).tap { |e| e.read_timeout = dispatch_deadline }
           end
       end
 

data/lib/cloudtasker/batch/job.rb

@@ -17,6 +17,10 @@ module Cloudtasker
       # because the jobs will be either retried or dropped
       IGNORED_ERRORED_CALLBACKS = %i[on_child_error on_child_dead].freeze
 
+      # The maximum number of seconds to wait for a batch state lock
+      # to be acquired.
+      BATCH_MAX_LOCK_WAIT = 60
+
       #
       # Return the cloudtasker redis client
       #
@@ -176,7 +180,9 @@ module Cloudtasker
       # @return [Hash] The state  of each child worker.
       #
       def batch_state
-        redis.fetch(batch_state_gid)
+        migrate_batch_state_to_redis_hash
+
+        redis.hgetall(batch_state_gid)
       end
 
       #
@@ -208,6 +214,24 @@ module Cloudtasker
         )
       end
 
+      #
+      # This method migrates the batch state to be a Redis hash instead
+      # of a hash stored in a string key.
+      #
+      def migrate_batch_state_to_redis_hash
+        return unless redis.type(batch_state_gid) == 'string'
+
+        # Migrate batch state to Redis hash if it is still using a legacy string key
+        # We acquire a lock then check again
+        redis.with_lock(batch_state_gid, max_wait: BATCH_MAX_LOCK_WAIT) do
+          if redis.type(batch_state_gid) == 'string'
+            state = redis.fetch(batch_state_gid)
+            redis.del(batch_state_gid)
+            redis.hset(batch_state_gid, state) if state.any?
+          end
+        end
+      end
+
       #
       # Save the batch.
       #
@@ -218,8 +242,11 @@ module Cloudtasker
         # complete (success or failure).
         redis.write(batch_gid, worker.to_h)
 
+        # Stop there if no jobs to save
+        return if jobs.empty?
+
         # Save list of child workers
-        redis.write(batch_state_gid, jobs.map { |e| [e.job_id, 'scheduled'] }.to_h)
+        redis.hset(batch_state_gid, jobs.map { |e| [e.job_id, 'scheduled'] }.to_h)
       end
 
       #
@@ -228,28 +255,27 @@ module Cloudtasker
       # @param [String] job_id The batch id.
       # @param [String] status The status of the sub-batch.
       #
-      # @return [<Type>] <description>
-      #
       def update_state(batch_id, status)
-        redis.with_lock(batch_state_gid) do
-          state = batch_state
-          state[batch_id.to_sym] = status.to_s if state.key?(batch_id.to_sym)
-          redis.write(batch_state_gid, state)
+        migrate_batch_state_to_redis_hash
+
+        # Update the batch state batch_id entry with the new status
+        redis.with_lock("#{batch_state_gid}/#{batch_id}", max_wait: BATCH_MAX_LOCK_WAIT) do
+          redis.hset(batch_state_gid, batch_id, status) if redis.hexists(batch_state_gid, batch_id)
         end
       end
 
       #
       # Return true if all the child workers have completed.
       #
-      # @return [<Type>] <description>
+      # @return [Boolean] True if the batch is complete.
       #
       def complete?
-        redis.with_lock(batch_state_gid) do
-          state = redis.fetch(batch_state_gid)
-          return true unless state
+        migrate_batch_state_to_redis_hash
 
+        # Check that all child jobs have completed
+        redis.with_lock(batch_state_gid, max_wait: BATCH_MAX_LOCK_WAIT) do
           # Check that all children are complete
-          state.values.all? { |e| COMPLETION_STATUSES.include?(e) }
+          redis.hvals(batch_state_gid).all? { |e| COMPLETION_STATUSES.include?(e) }
         end
       end
 
@@ -285,8 +311,8 @@ module Cloudtasker
         # Propagate event
         parent_batch&.on_child_complete(self, status)
 
-        # The batch tree is complete. Cleanup the tree.
-        cleanup unless parent_batch
+        # The batch tree is complete. Cleanup the downstream tree.
+        cleanup
       end
 
       #
@@ -331,11 +357,10 @@ module Cloudtasker
       # Remove all batch and sub-batch keys from Redis.
       #
       def cleanup
-        # Capture batch state
-        state = batch_state
+        migrate_batch_state_to_redis_hash
 
         # Delete child batches recursively
-        state.to_h.keys.each { |id| self.class.find(id)&.cleanup }
+        redis.hkeys(batch_state_gid).each { |id| self.class.find(id)&.cleanup }
 
         # Delete batch redis entries
         redis.del(batch_gid)
@@ -347,13 +372,20 @@ module Cloudtasker
       #
       # @return [Cloudtasker::Batch::BatchProgress] The batch progress.
       #
-      def progress
+      def progress(depth: 0)
+        depth = depth.to_i
+
         # Capture batch state
         state = batch_state
 
-        # Sum batch progress of current batch and all sub-batches
+        # Return immediately if we do not need to go down the tree
+        return BatchProgress.new(state) if depth <= 0
+
+        # Sum batch progress of current batch and sub-batches up to the specified
+        # depth
         state.to_h.reduce(BatchProgress.new(state)) do |memo, (child_id, child_status)|
-          memo + (self.class.find(child_id)&.progress || BatchProgress.new(child_id => child_status))
+          memo + (self.class.find(child_id)&.progress(depth: depth - 1) ||
+            BatchProgress.new(child_id => child_status))
         end
       end
 
@@ -395,7 +427,7 @@ module Cloudtasker
         # Perform job
         yield
 
-        # Save batch (if child worker has been enqueued)
+        # Save batch (if child workers have been enqueued)
         setup
 
         # Complete batch

data/lib/cloudtasker/cloud_task.rb

@@ -3,7 +3,7 @@
 module Cloudtasker
   # An interface class to manage tasks on the backend (Cloud Task or Redis)
   class CloudTask
-    attr_accessor :id, :http_request, :schedule_time, :retries, :queue
+    attr_accessor :id, :http_request, :schedule_time, :retries, :queue, :dispatch_deadline
 
     #
     # The backend to use for cloud tasks.
@@ -73,12 +73,13 @@ module Cloudtasker
     # @param [Integer] retries The number of times the job failed.
     # @param [String] queue The queue the task is in.
     #
-    def initialize(id:, http_request:, schedule_time: nil, retries: 0, queue: nil)
+    def initialize(id:, http_request:, schedule_time: nil, retries: 0, queue: nil, dispatch_deadline: nil)
       @id = id
       @http_request = http_request
       @schedule_time = schedule_time
       @retries = retries || 0
       @queue = queue
+      @dispatch_deadline = dispatch_deadline
     end
 
     #

data/lib/cloudtasker/config.rb

@@ -7,7 +7,7 @@ module Cloudtasker
   class Config
     attr_accessor :redis, :store_payloads_in_redis
     attr_writer :secret, :gcp_location_id, :gcp_project_id,
-                :gcp_queue_prefix, :processor_path, :logger, :mode, :max_retries
+                :gcp_queue_prefix, :processor_path, :logger, :mode, :max_retries, :dispatch_deadline
 
     # Max Cloud Task size in bytes
     MAX_TASK_SIZE = 100 * 1024 # 100 KB
@@ -46,6 +46,11 @@ module Cloudtasker
     DEFAULT_QUEUE_CONCURRENCY = 10
     DEFAULT_QUEUE_RETRIES = -1 # unlimited
 
+    # Job timeout configuration for Cloud Tasks
+    DEFAULT_DISPATCH_DEADLINE = 10 * 60 # 10 minutes
+    MIN_DISPATCH_DEADLINE = 15 # seconds
+    MAX_DISPATCH_DEADLINE = 30 * 60 # 30 minutes
+
     # The number of times jobs will be attempted before declaring them dead.
     #
     # With the default retry configuration (maxDoublings = 16 and minBackoff = 0.100s)
@@ -207,6 +212,16 @@ module Cloudtasker
       @gcp_location_id || DEFAULT_LOCATION_ID
     end
 
+    #
+    # Return the Dispatch deadline duration. Cloud Tasks will timeout the job after
+    # this duration is elapsed.
+    #
+    # @return [Integer] The value in seconds.
+    #
+    def dispatch_deadline
+      @dispatch_deadline || DEFAULT_DISPATCH_DEADLINE
+    end
+
     #
     # Return the secret to use to sign the verification tokens
     # attached to tasks.

data/lib/cloudtasker/redis_client.rb

@@ -75,14 +75,18 @@ module Cloudtasker
     #   end
     #
     # @param [String] cache_key The cache key to access.
+    # @param [Integer] max_wait The number of seconds after which the lock will be cleared anyway.
     #
-    def with_lock(cache_key)
+    def with_lock(cache_key, max_wait: nil)
       return nil unless cache_key
 
+      # Set max wait
+      max_wait = (max_wait || LOCK_DURATION).to_i
+
       # Wait to acquire lock
       lock_key = [LOCK_KEY_PREFIX, cache_key].join('/')
       client.with do |conn|
-        sleep(LOCK_WAIT_DURATION) until conn.set(lock_key, true, nx: true, ex: LOCK_DURATION)
+        sleep(LOCK_WAIT_DURATION) until conn.set(lock_key, true, nx: true, ex: max_wait)
       end
 
       # yield content

data/lib/cloudtasker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cloudtasker
-  VERSION = '0.12.rc4'
+  VERSION = '0.12.rc9'
 end

data/lib/cloudtasker/worker.rb

@@ -167,6 +167,22 @@ module Cloudtasker
       (@job_queue ||= self.class.cloudtasker_options_hash[:queue] || Config::DEFAULT_JOB_QUEUE).to_s
     end
 
+    #
+    # Return the Dispatch deadline duration. Cloud Tasks will timeout the job after
+    # this duration is elapsed.
+    #
+    # @return [Integer] The value in seconds.
+    #
+    def dispatch_deadline
+      @dispatch_deadline ||= [
+        [
+          Config::MIN_DISPATCH_DEADLINE,
+          (self.class.cloudtasker_options_hash[:dispatch_deadline] || Cloudtasker.config.dispatch_deadline).to_i
+        ].max,
+        Config::MAX_DISPATCH_DEADLINE
+      ].min
+    end
+
     #
     # Return the Cloudtasker logger instance.
     #
@@ -332,6 +348,22 @@ module Cloudtasker
       job_retries > job_max_retries
     end
 
+    #
+    # Return true if the job arguments are missing.
+    #
+    # This may happen if a job
+    # was successfully run but retried due to Cloud Task dispatch deadline
+    # exceeded. If the arguments were stored in Redis then they may have
+    # been flushed already after the successful completion.
+    #
+    # If job arguments are missing then the job will simply be declared dead.
+    #
+    # @return [Boolean] True if the arguments are missing.
+    #
+    def arguments_missing?
+      job_args.empty? && [0, -1].exclude?(method(:perform).arity)
+    end
+
     #
     # Return the time taken (in seconds) to perform the job. This duration
     # includes the middlewares and the actual perform method.
@@ -384,14 +416,9 @@ module Cloudtasker
       Cloudtasker.config.server_middleware.invoke(self) do
         # Immediately abort the job if it is already dead
         flag_as_dead if job_dead?
+        flag_as_dead(MissingWorkerArgumentsError.new('worker arguments are missing')) if arguments_missing?
 
         begin
-          # Abort if arguments are missing. This may happen with redis arguments storage
-          # if Cloud Tasks times out on a job but the job still succeeds
-          if job_args.empty? && [0, -1].exclude?(method(:perform).arity)
-            raise(MissingWorkerArgumentsError, 'worker arguments are missing')
-          end
-
           # Perform the job
           perform(*job_args)
         rescue StandardError => e

data/lib/cloudtasker/worker_handler.rb

@@ -14,12 +14,6 @@ module Cloudtasker
     # payloads in Redis
     REDIS_PAYLOAD_NAMESPACE = 'payload'
 
-    # Arg payload cache keys get expired instead of deleted
-    # in case jobs are re-processed due to connection interruption
-    # (job is successful but Cloud Task considers it as failed due
-    # to network interruption)
-    ARGS_PAYLOAD_CLEANUP_TTL = 3600 # 1 hour
-
     #
     # Return a namespaced key
     #
@@ -100,16 +94,13 @@ module Cloudtasker
       # Yied worker
       resp = yield(worker)
 
-      # Schedule args payload deletion after job has been successfully processed
-      # Note: we expire the key instead of deleting it immediately in case the job
-      # succeeds but is considered as failed by Cloud Task due to network interruption.
-      # In such case the job is likely to be re-processed soon after.
-      redis.expire(args_payload_key, ARGS_PAYLOAD_CLEANUP_TTL) if args_payload_key && !worker.job_reenqueued
+      # Delete stored args payload if job has completed
+      redis.del(args_payload_key) if args_payload_key && !worker.job_reenqueued
 
       resp
-    rescue DeadWorkerError, MissingWorkerArgumentsError => e
+    rescue DeadWorkerError => e
       # Delete stored args payload if job is dead
-      redis.expire(args_payload_key, ARGS_PAYLOAD_CLEANUP_TTL) if args_payload_key
+      redis.del(args_payload_key) if args_payload_key
       log_execution_error(worker, e)
       raise(e)
     rescue StandardError => e
@@ -165,6 +156,7 @@ module Cloudtasker
           },
           body: worker_payload.to_json
         },
+        dispatch_deadline: worker.dispatch_deadline.to_i,
         queue: worker.job_queue
       }
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cloudtasker
 version: !ruby/object:Gem::Version
-  version: 0.12.rc4
+  version: 0.12.rc9
 platform: ruby
 authors:
 - Arnaud Lachaume
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-29 00:00:00.000000000 Z
+date: 2021-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport