cloudtasker 0.11.rc1 → 0.12.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a0759638a4af47fcc26467b93039b3c6355908db5cafd0a20972b7e48649b81
-  data.tar.gz: a0f76c953bc0f64276f5b10f90300bcf7415dbfe305fac6697e4bd9fb83b53c0
+  metadata.gz: 11c4d8d88b554792e888929324e79521426f5484973253a44c50a97849a5842c
+  data.tar.gz: 1f10788d0ced509c82eea06ddfbd0b1d47a5731507c8bac5c597f41cc13b2d98
 SHA512:
-  metadata.gz: ef16621727a56793623e1c582bac1f6e4971b8ff1af3ee36a3d37b22d239f7bb3504a35b5f1ffc9f250343b2ed5ae888e75b8d583b49487f34dc69eb45cd9d13
-  data.tar.gz: aea0fa6eb2873f6b99df05c613d89363a3c6103fe814123d25a7508ede1fbf92cf653d10e7d57863d7ec6065d1c96e5c5f3ecf371a75ac925a588693849c320e
+  metadata.gz: abe6437f179edd589afb88ed970c7870377c836446ba6b4169ffd60565be15fcf92557dd71965795579f58ba19af63a9225ad55cf8c97bb8ab5612e31d5c8bdf
+  data.tar.gz: 23d17b1fade5f62594250b239b07e603bc8d8f0862465dd28ec3efc6b260cb86774e88d3b9aead4704eff1d071a3dda2f35d9d68302c6dcef56a1d8b707caffe

data/.rubocop.yml

@@ -13,6 +13,8 @@ Metrics/ModuleLength:
 
 Metrics/AbcSize:
   Max: 20
+  Exclude:
+    - 'spec/support/*'
 
 Metrics/LineLength:
   Max: 120
@@ -20,6 +22,10 @@ Metrics/LineLength:
 Metrics/MethodLength:
   Max: 20
 
+RSpec/DescribeClass:
+  Exclude:
+    - 'spec/integration/**/*_spec.rb'
+
 RSpec/ExpectInHook:
   Enabled: false
 
@@ -43,4 +49,9 @@ Metrics/ParameterLists:
   CountKeywordArgs: false
 
 RSpec/MessageSpies:
-  Enabled: false
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Exclude:
+    - 'examples/**/*'
+    - 'spec/integration/**/*'

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## Latest RC [v0.12.rc1](https://github.com/keypup-io/cloudtasker/tree/v0.12.rc1) (2021-03-11)
+
+[Full Changelog](https://github.com/keypup-io/cloudtasker/compare/v0.11.0...v0.12.rc1)
+
+**Improvements:**
+- ActiveJob: do not double log errors (ActiveJob has its own error logging)
+- 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)
+
+**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.
+
+## [v0.11.0](https://github.com/keypup-io/cloudtasker/tree/v0.11.0) (2021-03-11)
+
+[Full Changelog](https://github.com/keypup-io/cloudtasker/compare/v0.10.0...v0.11.0)
+
+**Improvements:**
+- Worker: drop job (return 205 response) when worker arguments are not available (e.g. arguments were stored in Redis and the latter was flushed)
+- Rails: add ActiveJob adapter (thanks @vovimayhem)
+
 ## [v0.10.1](https://github.com/keypup-io/cloudtasker/tree/v0.10.1) (2020-10-05)
 
 [Full Changelog](https://github.com/keypup-io/cloudtasker/compare/v0.10.0...v0.10.1)

data/README.md

@@ -12,10 +12,13 @@ Cloudtasker also provides optional modules for running [cron jobs](docs/CRON_JOB
 
 A local processing server is also available for development. This local server processes jobs in lieu of Cloud Tasks and allows you to work offline.
 
+**Maturity**: This gem is production-ready. We at Keypup have already processed millions of jobs using Cloudtasker and all related extensions (cron, batch and unique jobs). We are planning to release the official `v1.0.0` somewhere in 2021, in case we've missed any edge-case bug.
+
 ## Summary
 
 1. [Installation](#installation)
 2. [Get started with Rails](#get-started-with-rails)
+2. [Get started with Rails & ActiveJob](#get-started-with-rails--activejob)
 3. [Configuring Cloudtasker](#configuring-cloudtasker)
     1. [Cloud Tasks authentication & permissions](#cloud-tasks-authentication--permissions)
     2. [Cloudtasker initializer](#cloudtasker-initializer)
@@ -132,6 +135,95 @@ That's it! Your job was picked up by the Cloudtasker local server and sent for p
 
 Now jump to the next section to configure your app to use Google Cloud Tasks as a backend.
 
+## Get started with Rails & ActiveJob
+**Note**: ActiveJob is supported since `0.11.0`
+**Note**: Cloudtasker extensions (cron, batch and unique jobs) are not available when using cloudtasker via ActiveJob.
+
+Cloudtasker is pre-integrated with ActiveJob. Follow the steps below to get started.
+
+Install redis on your machine (this is required by the Cloudtasker local processing server)
+```bash
+# E.g. using brew
+brew install redis
+```
+
+Add the following initializer
+```ruby
+# config/initializers/cloudtasker.rb
+
+Cloudtasker.configure do |config|
+  #
+  # Adapt the server port to be the one used by your Rails web process
+  #
+  config.processor_host = 'http://localhost:3000'
+
+  #
+  # If you do not have any Rails secret_key_base defined, uncomment the following
+  # This secret is used to authenticate jobs sent to the processing endpoint
+  # of your application.
+  #
+  # config.secret = 'some-long-token'
+end
+```
+
+Configure ActiveJob to use Cloudtasker. You can also configure ActiveJob per environment via the config/environments/:env.rb files
+```ruby
+# config/application.rb
+
+require_relative 'boot'
+require 'rails/all'
+
+Bundler.require(*Rails.groups)
+
+module Dummy
+  class Application < Rails::Application
+    # Initialize configuration defaults for originally generated Rails version.
+    config.load_defaults 6.0
+
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration can go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded after loading
+    # the framework and any gems in your application.
+
+    # Use cloudtasker as the ActiveJob backend:
+    config.active_job.queue_adapter = :cloudtasker
+  end
+end
+
+```
+
+Define your first job:
+```ruby
+# app/jobs/example_job.rb
+
+class ExampleJob < ApplicationJob
+  queue_as :default
+
+  def perform(some_arg)
+    logger.info("Job run with #{some_arg}. This is working!")
+  end
+end
+```
+
+Launch Rails and the local Cloudtasker processing server (or add `cloudtasker` to your foreman config as a `worker` process)
+```bash
+# In one terminal
+> rails s -p 3000
+
+# In another terminal
+> cloudtasker
+```
+
+Open a Rails console and enqueue some jobs
+```ruby
+  # Process job as soon as possible
+  ExampleJob.perform_later('foo')
+
+  # Process job in 60 seconds
+  ExampleJob.set(wait: 60).perform_later('foo')
+```
+
+
 ## Configuring Cloudtasker
 
 ### Cloud Tasks authentication & permissions
@@ -361,6 +453,8 @@ CriticalWorker.schedule(args: [1], queue: :important)
 ```
 
 ## Extensions
+**Note**: Extensions are not available when using cloudtasker via ActiveJob.
+
 Cloudtasker comes with three optional features:
 - Cron Jobs [[docs](docs/CRON_JOBS.md)]: Run jobs at fixed intervals.
 - Batch Jobs [[docs](docs/BATCH_JOBS.md)]: Run jobs in jobs and track completion of the overall batch.

data/app/controllers/cloudtasker/worker_controller.rb

@@ -19,32 +19,19 @@ module Cloudtasker
       # Process payload
       WorkerHandler.execute_from_payload!(payload)
       head :no_content
-    rescue DeadWorkerError, MissingWorkerArgumentsError => e
+    rescue DeadWorkerError, MissingWorkerArgumentsError
       # 205: job will NOT be retried
-      log_error(e)
       head :reset_content
-    rescue InvalidWorkerError => e
+    rescue InvalidWorkerError
       # 404: Job will be retried
-      log_error(e)
       head :not_found
-    rescue StandardError => e
-      # 404: Job will be retried
-      log_error(e)
+    rescue StandardError
+      # 422: Job will be retried
       head :unprocessable_entity
     end
 
     private
 
-    #
-    # Log an error via cloudtasker logger.
-    #
-    # @param [Exception] e The error to log
-    #
-    def log_error(error)
-      Cloudtasker.logger.error(error)
-      Cloudtasker.logger.error(error.backtrace.join("\n"))
-    end
-
     #
     # Parse the request body and return the actual job
     # payload.

data/cloudtasker.gemspec

@@ -41,6 +41,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'github_changelog_generator'
   spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec-json_expectations', '~> 2.2'
   spec.add_development_dependency 'rubocop', '0.76.0'
   spec.add_development_dependency 'rubocop-rspec', '1.37.0'
   spec.add_development_dependency 'semantic_logger'

data/docs/BATCH_JOBS.md

@@ -1,4 +1,4 @@
-# Cloudtasker Unique Jobs
+# Cloudtasker Batch Jobs
 
 **Note**: this extension requires redis
 

data/lib/active_job/queue_adapters/cloudtasker_adapter.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# ActiveJob docs: http://guides.rubyonrails.org/active_job_basics.html
+# Example adapters ref: https://github.com/rails/rails/tree/master/activejob/lib/active_job/queue_adapters
+
+module ActiveJob
+  module QueueAdapters
+    # == Cloudtasker adapter for Active Job
+    #
+    # To use Cloudtasker set the queue_adapter config to +:cloudtasker+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :cloudtasker
+    class CloudtaskerAdapter
+      SERIALIZATION_FILTERED_KEYS = [
+        'executions', # Given by the worker at processing
+        'provider_job_id', # Also given by the worker at processing
+        'priority' # Not used
+      ].freeze
+
+      # Enqueues the given ActiveJob instance for execution
+      #
+      # @param job [ActiveJob::Base] The ActiveJob instance
+      #
+      # @return [Cloudtasker::CloudTask] The Google Task response
+      #
+      def enqueue(job)
+        build_worker(job).schedule
+      end
+
+      # Enqueues the given ActiveJob instance for execution at a given time
+      #
+      # @param job [ActiveJob::Base] The ActiveJob instance
+      # @param precise_timestamp [Integer] The timestamp at which the job must be executed
+      #
+      # @return [Cloudtasker::CloudTask] The Google Task response
+      #
+      def enqueue_at(job, precise_timestamp)
+        build_worker(job).schedule(time_at: Time.at(precise_timestamp))
+      end
+
+      private
+
+      def build_worker(job)
+        job_serialization = job.serialize.except(*SERIALIZATION_FILTERED_KEYS)
+
+        JobWrapper.new(
+          job_id: job_serialization.delete('job_id'),
+          job_queue: job_serialization.delete('queue_name'),
+          job_args: [job_serialization]
+        )
+      end
+
+      # == Job Wrapper for the Cloudtasker adapter
+      #
+      # Executes jobs scheduled by the Cloudtasker ActiveJob adapter
+      class JobWrapper #:nodoc:
+        include Cloudtasker::Worker
+
+        # Executes the given serialized ActiveJob call.
+        # - See https://api.rubyonrails.org/classes/ActiveJob/Core.html#method-i-serialize
+        #
+        # @param [Hash] job_serialization The serialized ActiveJob call
+        #
+        # @return [any] The execution of the ActiveJob call
+        #
+        def perform(job_serialization, *_extra_options)
+          job_executions = job_retries < 1 ? 0 : (job_retries + 1)
+
+          job_serialization.merge!(
+            'job_id' => job_id,
+            'queue_name' => job_queue,
+            'provider_job_id' => task_id,
+            'executions' => job_executions,
+            'priority' => nil
+          )
+
+          Base.execute job_serialization
+        end
+      end
+    end
+  end
+end

data/lib/cloudtasker/backend/redis_task.rb

@@ -23,14 +23,12 @@ module Cloudtasker
       #
       # Return a namespaced key.
       #
-      # @param [String, Symbol] val The key to namespace
+      # @param [String, Symbol, nil] val The key to namespace
       #
       # @return [String] The namespaced key.
       #
-      def self.key(val)
-        return nil if val.nil?
-
-        [to_s.underscore, val.to_s].join('/')
+      def self.key(val = nil)
+        [to_s.underscore, val].compact.map(&:to_s).join('/')
       end
 
       #
@@ -39,9 +37,17 @@ module Cloudtasker
       # @return [Array<Cloudtasker::Backend::RedisTask>] All the tasks.
       #
       def self.all
-        redis.search(key('*')).map do |gid|
-          payload = redis.fetch(gid)
-          new(payload.merge(id: gid.sub(key(''), '')))
+        if redis.exists?(key)
+          # Use Schedule Set if available
+          redis.smembers(key).map { |id| find(id) }
+        else
+          # Fallback to redis key matching and migrate tasks
+          # to use Task Set instead.
+          redis.search(key('*')).map do |gid|
+            task_id = gid.sub(key(''), '')
+            redis.sadd(key, task_id)
+            find(task_id)
+          end
         end
       end
 
@@ -82,6 +88,7 @@ module Cloudtasker
 
         # Save job
         redis.write(key(id), payload)
+        redis.sadd(key, id)
         new(payload.merge(id: id))
       end
 
@@ -105,6 +112,7 @@ module Cloudtasker
       # @param [String] id The task id.
       #
       def self.delete(id)
+        redis.srem(key, id)
         redis.del(key(id))
       end
 
@@ -176,7 +184,7 @@ module Cloudtasker
       # Remove the task from the queue.
       #
       def destroy
-        redis.del(gid)
+        self.class.delete(id)
       end
 
       #

data/lib/cloudtasker/batch/job.rb

@@ -13,6 +13,10 @@ module Cloudtasker
       # List of statuses triggering a completion callback
       COMPLETION_STATUSES = %w[completed dead].freeze
 
+      # These callbacks do not need to raise errors on their own
+      # because the jobs will be either retried or dropped
+      IGNORED_ERRORED_CALLBACKS = %i[on_child_error on_child_dead].freeze
+
       #
       # Return the cloudtasker redis client
       #
@@ -62,6 +66,10 @@ module Cloudtasker
       # @return [Cloudtasker::Batch::Job] The attached batch.
       #
       def self.for(worker)
+        # Load extension if not loaded already on the worker class
+        worker.class.include(Extension::Worker) unless worker.class <= Extension::Worker
+
+        # Add batch capability
         worker.batch = new(worker)
       end
 
@@ -246,8 +254,8 @@ module Cloudtasker
       end
 
       #
-      # Run worker callback in a controlled environment to
-      # avoid interruption of the callback flow.
+      # Run worker callback. The error and dead callbacks get
+      # silenced should they raise an error.
       #
       # @param [String, Symbol] callback The callback to run.
       # @param [Array<any>] *args The callback arguments.
@@ -257,9 +265,14 @@ module Cloudtasker
       def run_worker_callback(callback, *args)
         worker.try(callback, *args)
       rescue StandardError => e
-        Cloudtasker.logger.error("Error running callback #{callback}: #{e}")
-        Cloudtasker.logger.error(e.backtrace.join("\n"))
-        nil
+        # There is no point in retrying jobs due to failure callbacks failing
+        # Only completion callbacks will trigger a re-run of the job because
+        # these do matter for batch completion
+        raise(e) unless IGNORED_ERRORED_CALLBACKS.include?(callback)
+
+        # Log error instead
+        worker.logger.error(e)
+        worker.logger.error("Callback #{callback} failed to run. Skipping to preserve error flow.")
       end
 
       #
@@ -271,7 +284,7 @@ module Cloudtasker
 
         # Propagate event
         parent_batch&.on_child_complete(self, status)
-      ensure
+
         # The batch tree is complete. Cleanup the tree.
         cleanup unless parent_batch
       end

data/lib/cloudtasker/batch/middleware.rb

@@ -16,6 +16,8 @@ module Cloudtasker
         Cloudtasker.configure do |config|
           config.server_middleware { |c| c.add(Middleware::Server) }
         end
+
+        # Inject worker extension on main module
         Cloudtasker::Worker.include(Extension::Worker)
       end
     end

data/lib/cloudtasker/cli.rb

@@ -64,6 +64,7 @@ module Cloudtasker
       return false unless File.exist?('./config/environment.rb')
 
       require 'rails'
+      require 'cloudtasker/engine'
       require File.expand_path('./config/environment.rb')
     end
 

data/lib/cloudtasker/cron/schedule.rb

@@ -21,14 +21,12 @@ module Cloudtasker
       #
       # Return a namespaced key.
       #
-      # @param [String, Symbol] val The key to namespace
+      # @param [String, Symbol, nil] val The key to namespace
       #
       # @return [String] The namespaced key.
       #
-      def self.key(val)
-        return nil if val.nil?
-
-        [to_s.underscore, val.to_s].join('/')
+      def self.key(val = nil)
+        [to_s.underscore, val].compact.map(&:to_s).join('/')
       end
 
       #
@@ -37,8 +35,17 @@ module Cloudtasker
       # @return [Array<Cloudtasker::Batch::Schedule>] The list of stored schedules.
       #
       def self.all
-        redis.search(key('*')).map do |gid|
-          find(gid.sub(key(''), ''))
+        if redis.exists?(key)
+          # Use Schedule Set if available
+          redis.smembers(key).map { |id| find(id) }
+        else
+          # Fallback to redis key matching and migrate schedules
+          # to use Schedule Set instead.
+          redis.search(key('*')).map do |gid|
+            schedule_id = gid.sub(key(''), '')
+            redis.sadd(key, schedule_id)
+            find(schedule_id)
+          end
         end
       end
 
@@ -90,7 +97,7 @@ module Cloudtasker
       end
 
       #
-      # Destroy a schedule by id.
+      # Delete a schedule by id.
       #
       # @param [String] id The schedule id.
       #
@@ -101,6 +108,7 @@ module Cloudtasker
 
           # Delete task and stored schedule
           CloudTask.delete(schedule.task_id) if schedule.task_id
+          redis.srem(key, schedule.id)
           redis.del(schedule.gid)
         end
       end
@@ -270,6 +278,7 @@ module Cloudtasker
 
         # Save schedule
         config_was_changed = config_changed?
+        redis.sadd(self.class.key, id)
         redis.write(gid, to_h)
 
         # Stop there if backend does not need update

data/lib/cloudtasker/engine.rb

@@ -5,10 +5,14 @@ module Cloudtasker
   class Engine < ::Rails::Engine
     isolate_namespace Cloudtasker
 
-    initializer 'cloudtasker', before: :load_config_initializers do
+    config.before_initialize do
+      # Mount cloudtasker processing endpoint
       Rails.application.routes.append do
         mount Cloudtasker::Engine, at: '/cloudtasker'
       end
+
+      # Add ActiveJob adapter
+      require 'active_job/queue_adapters/cloudtasker_adapter' if defined?(::ActiveJob::Railtie)
     end
 
     config.generators do |g|

data/lib/cloudtasker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cloudtasker
-  VERSION = '0.11.rc1'
+  VERSION = '0.12.rc2'
 end

data/lib/cloudtasker/worker.rb

@@ -311,13 +311,25 @@ module Cloudtasker
     end
 
     #
-    # Return true if the job has excceeded its maximum number
-    # of retries
+    # Return true if the job must declared dead upon raising
+    # an error.
+    #
+    # @return [Boolean] True if the job must die on error.
+    #
+    def job_must_die?
+      job_retries >= job_max_retries
+    end
+
+    #
+    # Return true if the job has strictly excceeded its maximum number
+    # of retries.
+    #
+    # Used a preemptive filter when running the job.
     #
     # @return [Boolean] True if the job is dead
     #
     def job_dead?
-      job_retries >= job_max_retries
+      job_retries > job_max_retries
     end
 
     #
@@ -332,11 +344,35 @@ module Cloudtasker
       (perform_ended_at - perform_started_at).ceil(3)
     end
 
+    #
+    # Run worker callback.
+    #
+    # @param [String, Symbol] callback The callback to run.
+    # @param [Array<any>] *args The callback arguments.
+    #
+    # @return [any] The callback return value
+    #
+    def run_callback(callback, *args)
+      try(callback, *args)
+    end
+
     #=============================
     # Private
     #=============================
     private
 
+    #
+    # Flag the worker as dead by invoking the on_dead hook
+    # and raising a DeadWorkerError
+    #
+    # @param [Exception, nil] error An optional exception to be passed to the DeadWorkerError.
+    #
+    def flag_as_dead(error = nil)
+      run_callback(:on_dead, error || DeadWorkerError.new)
+    ensure
+      raise(DeadWorkerError, error)
+    end
+
     #
     # Execute the worker perform method through the middleware chain.
     #
@@ -346,6 +382,9 @@ module Cloudtasker
       self.perform_started_at = Time.now
 
       Cloudtasker.config.server_middleware.invoke(self) do
+        # Immediately abort the job if it is already dead
+        flag_as_dead if job_dead?
+
         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
@@ -356,12 +395,11 @@ module Cloudtasker
           # Perform the job
           perform(*job_args)
         rescue StandardError => e
-          try(:on_error, e)
-          return raise(e) unless job_dead?
+          run_callback(:on_error, e)
+          return raise(e) unless job_must_die?
 
           # Flag job as dead
-          try(:on_dead, e)
-          raise(DeadWorkerError, e)
+          flag_as_dead(e)
         end
       end
     ensure

data/lib/cloudtasker/worker_handler.rb

@@ -45,6 +45,28 @@ module Cloudtasker
       end
     end
 
+    #
+    # Log error on execution failure.
+    #
+    # @param [Cloudtasker::Worker, nil] worker The worker.
+    # @param [Exception] error The error to log.
+    #
+    # @void
+    #
+    def self.log_execution_error(worker, error)
+      # ActiveJob has its own error logging. No need to double log the error.
+      # Note: we use string matching instead of class matching as
+      # ActiveJob::QueueAdapters::CloudtaskerAdapter::JobWrapper might not be loaded
+      return if worker.class.to_s =~ /^ActiveJob::/
+
+      # Choose logger to use based on context
+      # Worker will be nil on InvalidWorkerError - in that case we use generic logging
+      logger = worker&.logger || Cloudtasker.logger
+
+      # Log error
+      logger.error(error)
+    end
+
     #
     # Execute a task worker from a task payload
     #
@@ -88,6 +110,10 @@ module Cloudtasker
     rescue DeadWorkerError, MissingWorkerArgumentsError => e
       # Delete stored args payload if job is dead
       redis.expire(args_payload_key, ARGS_PAYLOAD_CLEANUP_TTL) if args_payload_key
+      log_execution_error(worker, e)
+      raise(e)
+    rescue StandardError => e
+      log_execution_error(worker, e)
       raise(e)
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cloudtasker
 version: !ruby/object:Gem::Version
-  version: 0.11.rc1
+  version: 0.12.rc2
 platform: ruby
 authors:
 - Arnaud Lachaume
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-16 00:00:00.000000000 Z
+date: 2021-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -178,6 +178,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-json_expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -343,6 +357,7 @@ files:
 - gemfiles/semantic_logger_4.7.0.gemfile
 - gemfiles/semantic_logger_4.7.2.gemfile
 - gemfiles/semantic_logger_4.7.gemfile
+- lib/active_job/queue_adapters/cloudtasker_adapter.rb
 - lib/cloudtasker.rb
 - lib/cloudtasker/authentication_error.rb
 - lib/cloudtasker/authenticator.rb