taskinator 0.4.2 → 0.4.6

data/README.md

@@ -1,25 +1,29 @@
 # Taskinator
 
 [![Gem Version](https://badge.fury.io/rb/taskinator.svg)](http://badge.fury.io/rb/taskinator)
-[![Build Status](https://secure.travis-ci.org/virtualstaticvoid/taskinator.png?branch=master)](http://travis-ci.org/virtualstaticvoid/taskinator)
+[![Build Status](https://img.shields.io/github/workflow/status/virtualstaticvoid/taskinator/Taskinator?style=flat-square)](https://github.com/virtualstaticvoid/taskinator/actions)
 [![Code Climate](https://codeclimate.com/github/virtualstaticvoid/taskinator.png)](https://codeclimate.com/github/virtualstaticvoid/taskinator)
-[![Coverage Status](https://coveralls.io/repos/virtualstaticvoid/taskinator/badge.png)](https://coveralls.io/r/virtualstaticvoid/taskinator)
 
-A simple orchestration library for running complex processes or workflows in Ruby. Processes are defined using a simple DSL, where the sequences and
-tasks are defined. Processes can then be queued for execution. Sequences can be synchronous or asynchronous, and the overall process can be monitored
-for completion or failure.
+A simple orchestration library for running complex processes or workflows in Ruby.
+Processes are defined using a simple DSL, where the sequences and tasks are defined.
+Processes can then be queued for execution. Sequences can be synchronous or asynchronous,
+and the overall process can be monitored for completion or failure.
 
-Processes and tasks are executed by background workers and you can use any one of the following gems:
+Processes and tasks are executed by background workers and you can use any one of the
+following gems:
 
+* [active_job](https://github.com/rails/rails/tree/main/activejob)
 * [resque](https://github.com/resque/resque)
 * [sidekiq](https://github.com/mperham/sidekiq)
 * [delayed_job](https://github.com/collectiveidea/delayed_job)
 
-The configuration and state of each process and their respective tasks is stored using Redis key/values.
+The configuration and state of each process and their respective tasks is stored using
+Redis key/values.
 
 ## Requirements
 
-The latest MRI (2.1, 2.0) version. Other versions/VMs are untested but might work fine. MRI 1.9 is not supported.
+The latest MRI 2.x or 3.x version. Other versions/VMs are untested, but might work fine.
+MRI 1.x is not supported.
 
 Redis 2.4 or greater is required.
 
@@ -35,12 +39,34 @@ Add this line to your application's Gemfile:
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 Or install it yourself as:
 
     $ gem install taskinator
 
+If you are using Taskinator within a Rails application, then add an initializer, such as
+`config/initializers/taskinator.rb`, with the following configuration content:
+
+```ruby
+# config/initializers/taskinator.rb
+Taskinator.configure do |config|
+
+  # configure the queue adapter to use
+  # can be :active_job, :delayed_job, :redis or :sidekiq
+  config.queue_adapter = :redis
+
+  # configure redis
+  config.redis = {
+    :url => 'redis://redis.example.com:7372/12',
+    :namespace => 'mynamespace'
+  }
+
+end
+```
+
+See the configuration section below for more configuration details.
+
 ## Usage
 
 ### Definition
@@ -49,6 +75,7 @@ Start by creating a "process" module and extending `Taskinator::Definition`.
 
 ```ruby
 require 'taskinator'
+
 module MyProcess
   extend Taskinator::Definition
 
@@ -68,7 +95,8 @@ module MyProcess
 end
 ```
 
-The `define_process` method optionally takes the list of expected arguments which are used to validate the arguments supplied when creating a new process.
+The `define_process` method optionally takes the list of expected arguments which are used
+to validate the arguments supplied when creating a new process.
 These should be specified with symbols.
 
 ```ruby
@@ -87,7 +115,8 @@ process = MyProcess.create_process Date.today, :option_1 => true
 
 _NOTE:_ The current implementation performs a naive check on the count of arguments.
 
-Next, specify the tasks with their corresponding implementation methods, that make up the process, using the `task` method and providing the `method` to execute for the task.
+Next, specify the tasks with their corresponding implementation methods, that make up the
+process, using the `task` method and providing the `method` to execute for the task.
 
 ```ruby
 module MyProcess
@@ -108,7 +137,8 @@ module MyProcess
 end
 ```
 
-More complex processes may define sequential or concurrent steps, using the `sequential` and `concurrent` methods respectively.
+More complex processes may define sequential or concurrent steps, using the `sequential`
+and `concurrent` methods respectively.
 
 ```ruby
 module MyProcess
@@ -141,10 +171,16 @@ module MyProcess
 end
 ```
 
-It is likely that you already have worker classes for one of the queueing libraries, such as resque or delayed_job, and wish to reuse them for executing them in the sequence defined by the process definition.
+#### Reusing ActiveJob jobs
 
-Define a `job` step, providing the class of the worker, and then taskinator will execute that worker as part of the process definition.
-The `job` step will be queued and executed on same queue as configured by `delayed_job`, or that of the worker for `resque` and `sidekiq`.
+It is likely that you already have one or more [jobs](https://guides.rubyonrails.org/active_job_basics.html)
+and want to reuse them within the process definition.
+
+Define a `job` step, providing the class of the Active Job to run and then taskinator will
+invoke that job as part of the process.
+
+The `job` step will be queued and executed on same queue as
+[configured by the job](https://guides.rubyonrails.org/active_job_basics.html#queues).
 
 ```ruby
 # E.g. A resque worker
@@ -168,8 +204,13 @@ module MyProcess
 end
 ```
 
-You can also define data driven tasks using the `for_each` method, which takes an iterator method name as an argument.
-The iterator method yields the parameters necessary for the task or job. Notice that the task method takes a parameter in this case, which will be the return values provided by the iterator.
+#### Data Driven Process Definitions
+
+You can also define data driven tasks using the `for_each` method, which takes an iterator method
+name as an argument.
+
+The iterator method yields the parameters necessary for the task or job. Notice that the task
+method takes a parameter in this case, which will be the return values provided by the iterator.
 
 ```ruby
 module MyProcess
@@ -192,8 +233,11 @@ module MyProcess
 end
 ```
 
-It is possible to branch the process logic based on the options hash passed in when creating a process.
-The `options?` method takes the options key as an argument and calls the supplied block if the option is present and it's value is truthy.
+#### Branching
+
+It is possible to branch the process logic based on the options hash passed in when creating
+a process. The `options?` method takes the options key as an argument and calls the supplied
+block if the option is present and it's value is _truthy_.
 
 ```ruby
 module MyProcess
@@ -227,8 +271,13 @@ process2 = MyProcess.create_process
 process2.tasks.count #=> 1
 ```
 
-In addition, it is possible to transform the arguments used by a task or job, by including a `transform` step in the definition.
-Similarly for the `for_each` method, `transform` takes a method name as an argument. The transformer method must yield the new arguments as required.
+#### Transformations
+
+In addition, it is possible to transform the arguments used by a task or job, by including
+a `transform` step in the definition.
+
+Similarly for the `for_each` method, `transform` takes a method name as an argument.
+The transformer method must yield the new arguments as required.
 
 ```ruby
 module MyProcess
@@ -252,6 +301,8 @@ module MyProcess
 end
 ```
 
+#### Subprocesses
+
 Processes can be composed of other processes too:
 
 ```ruby
@@ -273,7 +324,10 @@ module MyProcess
 end
 ```
 
-Any combination or nesting of `task`, `sequential`, `concurrent` and `for_each` steps are possible. E.g.
+#### Complex Process Definitions
+
+Any combination or nesting of `task`, `sequential`, `concurrent` and `for_each` steps are
+possible. E.g.
 
 ```ruby
 module MyProcess
@@ -306,13 +360,17 @@ module MyProcess
 end
 ```
 
-In this example, the `work_step_begin` is executed, followed by the `work_step_all_at_once` steps which are executed concurrently, then
-the sub process `MySubProcess` is created and executed, followed by the `work_step_one_by_one` tasks which are executed sequentially and
+In this example, the `work_step_begin` is executed, followed by the `work_step_all_at_once`
+steps which are executed concurrently, then the sub process `MySubProcess` is created and
+executed, followed by the `work_step_one_by_one` tasks which are executed sequentially and
 finally the `work_step_end` is executed.
 
-It is also possible to embed conditional logic within the process definition stages in order to produce steps based on the required logic.
-All builder methods are available within the scope of the `define_process` block. These methods include `args` and `options`
-which are passed into the `create_process` method of the definition.
+It is also possible to embed conditional logic within the process definition stages in
+order to produce steps based on the required logic.
+
+All builder methods are available within the scope of the `define_process` block. These
+methods include `args` and `options` which are passed into the `create_process` method
+of the definition.
 
 E.g.
 
@@ -332,7 +390,8 @@ module MyProcess
 end
 
 # when creating this proces, you supply to option when calling `create_process`
-# in this example, 'args' will be an array [1,2,3] and options will be a Hash {:send_notification => true}
+# in this example, 'args' will be an array [1,2,3]
+# and options will be a Hash {:send_notification => true}
 MyProcess.create_process(1, 2, 3, :send_notification => true)
 
 ```
@@ -364,8 +423,12 @@ To best understand how arguments are handled, you need to break it down into 3 p
   * Creation and
   * Execution
 
-Firstly, a process definition is declarative in that the `define_process` and a mix of `sequential`, `concurrent`, `for_each`, `task` and `job` directives provide the way to specify the sequencing of the steps for the process.
-Taskinator will interprete this definition and execute each step in the desired sequence or concurrency.
+Firstly, a process definition is declarative in that the `define_process` and a mix of
+`sequential`, `concurrent`, `for_each`, `task` and `job` directives provide the way to
+specify the sequencing of the steps for the process.
+
+Taskinator will interprete this definition and execute each step in the desired sequence
+or concurrency.
 
 Consider the following process definition:
 
@@ -411,11 +474,17 @@ end
 
 There are three tasks; namely `:work_step_1`, `:work_step_2` and `:work_step_3`.
 
-The third task, `:work_step_3`, is built up using the `for_each` iterator, which means that the number of `:work_step_3` tasks will depend on how many times the `additional_step` iterator method yields to the definition.
+The third task, `:work_step_3`, is built up using the `for_each` iterator, which means that
+the number of `:work_step_3` tasks will depend on how many times the `additional_step`
+iterator method yields to the definition.
+
+This brings us to the creation part. When `create_process` is called on the given module,
+you provide arguments to it, which will get passed onto the respective `task` and
+`for_each` iterator methods.
 
-This brings us to the creation part. When `create_process` is called on the given module, you provide arguments to it, which will get passed onto the respective `task` and `for_each` iterator methods.
+So, considering the `MySimpleProcess` module shown above, `work_step_1`, `work_step_2`
+and `work_step_3` methods each expect arguments.
 
-So, considering the `MySimpleProcess` module shown above, `work_step_1`, `work_step_2` and `work_step_3` methods each expect arguments.
 These will ultimately come from the arguments passed into the `create_process` method.
 
 E.g.
@@ -438,7 +507,8 @@ process = MySimpleProcess.create_process(options)
 
 ```
 
-To best understand how the process is created, consider the following "procedural" code for how it could work.
+To best understand how the process is created, consider the following "procedural" code
+for how it could work.
 
 ```ruby
 # A process, which maps the target and a list of steps
@@ -535,11 +605,17 @@ process.execute
 
 ```
 
-In reality, each task is executed by a worker process, possibly on another host, so the execution process isn't as simple, but this example should help you to understand conceptually how the process is executed, and how the arguments are propagated through.
+In reality, each task is executed by a worker process, possibly on another host, so the
+execution process isn't as simple, but this example should help you to understand
+conceptually how the process is executed, and how the arguments are propagated through.
 
 ### Monitoring
 
-To monitor the state of the processes, use the `Taskinator::Api::Processes` class. This is still a work in progress.
+NOTE: This aspect of the library is still a work in progress.
+
+#### Processes
+
+To monitor the state of the processes, use the `Taskinator::Api::Processes` class.
 
 ```ruby
 processes = Taskinator::Api::Processes.new
@@ -549,51 +625,130 @@ processes.each do |process|
 end
 ```
 
+#### Debugging
+
+To aid debugging specific processes and tasks, where the process or task identifier is
+known, it is possible to retrieve the specific task or process using `Taskinator::Api`.
+
+To retrieve a specific process, given the process identifier:
+
+```ruby
+process_id = "SUPPLY-PROCESS-IDENTIFIER"
+process = Taskinator::Api.find_process(process_id)
+
+puts process.inspect
+puts process.current_state
+puts process.tasks
+# etc...
+```
+
+The type of process may be one of the following:
+
+* `Taskinator::Process::Sequential`
+* `Taskinator::Process::Concurrent`
+
+Then, to retrieve a specific task, given the task identifier:
+
+```ruby
+task_id = "SUPPLY-TASK-IDENTIFIER"
+task = Taskinator::Api.find_task(task_id)
+
+puts task.inspect
+puts task.class
+puts task.args                # for Step and Job types
+puts task.sub_process.tasks   # for SubProcess type
+# etc...
+```
+
+Depending on the type of task, different attributes will be available for inspection.
+
+The types include:
+
+* `Taskinator::Task::Step`
+* `Taskinator::Task::Job`
+* `Taskinator::Task::SubProcess`
+
 ## Configuration
 
 ### Redis
 
-By default Taskinator assumes Redis is located at `localhost:6397`. This is fine for development, but for many production environments you will need to point to an external Redis server. You may also what to use a namespace for the Redis keys.
+By default Taskinator assumes Redis is located at `localhost:6397`. This is fine for development,
+but for many production environments you will need to point to an external Redis server.
+You may also what to use a namespace for the Redis keys.
+
 _NOTE:_ The configuration hash _must_ have symbolized keys.
 
 ```ruby
 Taskinator.configure do |config|
- config.redis = {
-   :url => 'redis://redis.example.com:7372/12',
-   :namespace => 'mynamespace'
- }
+
+  # redis configuration
+  config.redis = {
+    :url => 'redis://redis.example.com:7372/12',
+    :namespace => 'mynamespace'
+  }
+
 end
 ```
 
 Or, alternatively, via an `ENV` variable
 
 Set the `REDIS_PROVIDER` environment variable to the Redis server url.
-E.g. On Heroku, with RedisGreen: set REDIS_PROVIDER=REDISGREEN_URL and Taskinator will use the value of the `REDISGREEN_URL` environment variable when connecting to Redis.
+E.g. On Heroku, with RedisGreen: set `REDIS_PROVIDER=REDISGREEN_URL` and Taskinator will use the
+value of the `REDISGREEN_URL` environment variable when connecting to Redis.
 
 You may also use the generic `REDIS_URL` which may be set to your own private Redis server.
 
-The Redis configuration leverages the same setup as `sidekiq`. For advanced options, checkout the [Sidekiq Advanced Options](https://github.com/mperham/sidekiq/wiki/Advanced-Options#complete-control) wiki for more information.
+The Redis configuration leverages the same setup as `sidekiq`. For advanced options, checkout the
+[Sidekiq Advanced Options](https://github.com/mperham/sidekiq/wiki/Advanced-Options#complete-control)
+wiki page for more information.
 
 ### Queues
 
-By default the queue names for process and task workers is `default`, however, you can specify the queue names as follows:
+To configure the queue adapter to use, set `config.queue_adapter` to one of the following values:
+
+* `:active_job`
+* `:delayed_job`
+* `:redis`
+* `:sidekiq`
+
+As follows:
 
 ```ruby
 Taskinator.configure do |config|
+
+  # configure the queue adapter to use
+  # can be :active_job, :delayed_job, :redis or :sidekiq
+  config.queue_adapter = :redis
+
+end
+```
+
+By default the queue names for process and task workers is `default`, however, you can specify
+the queue names as follows:
+
+```ruby
+Taskinator.configure do |config|
+
+  # queue configuration
   config.queue_config = {
     :process_queue => :default,
     :task_queue => :default
   }
+
 end
 ```
 
 ### Instrumentation
 
-It is possible to instrument processes, tasks and jobs by providing an instrumeter such as `ActiveSupport::Notifications`.
+It is possible to instrument processes, tasks and jobs by providing an instrumeter such
+as `ActiveSupport::Notifications`.
 
 ```ruby
 Taskinator.configure do |config|
+
+  # configure instrumenter to use
   config.instrumenter = ActiveSupport::Notifications
+
 end
 ```
 
@@ -601,46 +756,50 @@ Alternatively, you can use the built-in instrumenter for logging to the console
 
 ```ruby
 Taskinator.configure do |config|
+
+  # configure instrumenter to use
   config.instrumenter = Taskinator::ConsoleInstrumenter.new
+
 end
 ```
 
 The following instrumentation events are issued:
 
-| Event                              | When                                                      |
-|------------------------------------|-----------------------------------------------------------|
-| `taskinator.process.created`       | After a root process gets created                         |
-| `taskinator.process.saved`         | After a root process has been persisted to Redis          |
-| `taskinator.process.enqueued`      | After a process or subprocess is enqueued for processing  |
-| `taskinator.process.processing`    | When a process or subprocess is processing                |
-| `taskinator.process.paused`        | When a process or subprocess is paused                    |
-| `taskinator.process.resumed`       | When a process or subprocess is resumed                   |
-| `taskinator.process.completed`     | After a process or subprocess has completed processing    |
-| `taskinator.process.cancelled`     | After a process or subprocess has been cancelled          |
-| `taskinator.process.failed`        | After a process or subprocess has failed                  |
-| `taskinator.task.enqueued`         | After a task has been enqueued                            |
-| `taskinator.task.processing`       | When a task is processing                                 |
-| `taskinator.task.completed`        | After a task has completed                                |
-| `taskinator.task.cancelled`        | After a task has been cancelled                           |
-| `taskinator.task.failed`           | After a task has failed                                   |
+| Event                           | When                                                     |
+|---------------------------------|----------------------------------------------------------|
+| `taskinator.process.created`    | After a root process gets created                        |
+| `taskinator.process.saved`      | After a root process has been persisted to Redis         |
+| `taskinator.process.enqueued`   | After a process or subprocess is enqueued for processing |
+| `taskinator.process.processing` | When a process or subprocess is processing               |
+| `taskinator.process.paused`     | When a process or subprocess is paused                   |
+| `taskinator.process.resumed`    | When a process or subprocess is resumed                  |
+| `taskinator.process.completed`  | After a process or subprocess has completed processing   |
+| `taskinator.process.cancelled`  | After a process or subprocess has been cancelled         |
+| `taskinator.process.failed`     | After a process or subprocess has failed                 |
+| `taskinator.task.enqueued`      | After a task has been enqueued                           |
+| `taskinator.task.processing`    | When a task is processing                                |
+| `taskinator.task.completed`     | After a task has completed                               |
+| `taskinator.task.cancelled`     | After a task has been cancelled                          |
+| `taskinator.task.failed`        | After a task has failed                                  |
 
 For all events, the data included contains the following information:
 
-| Key                      | Value                                                 |
-|--------------------------|-------------------------------------------------------|
-| `:type`                  | The type name of the component reporting the event    |
-| `:process_uuid`          | The UUID of the root process                          |
-| `:process_options`       | Options hash of the root process                      |
-| `:uuid`                  | The UUID of the respective task, job or sub process   |
-| `:options`               | Options hash of the component                         |
-| `:state`                 | State of the component                                |
-| `:percentage_completed`  | The percentage of completed tasks                     |
-| `:percentage_failed`     | The percentage of failed tasks                        |
-| `:percentage_cancelled`  | The percentage of cancelled tasks                     |
+| Key                             | Value                                                    |
+|---------------------------------|----------------------------------------------------------|
+| `:type`                         | The type name of the component reporting the event       |
+| `:process_uuid`                 | The UUID of the root process                             |
+| `:process_options`              | Options hash of the root process                         |
+| `:uuid`                         | The UUID of the respective task, job or sub process      |
+| `:options`                      | Options hash of the component                            |
+| `:state`                        | State of the component                                   |
+| `:percentage_completed`         | The percentage of completed tasks                        |
+| `:percentage_failed`            | The percentage of failed tasks                           |
+| `:percentage_cancelled`         | The percentage of cancelled tasks                        |
 
 ## Notes
 
-The persistence logic is decoupled from the implementation, so it is possible to implement another backing store if required.
+The persistence logic is decoupled from the implementation, so it is possible to implement
+another backing store if required.
 
 ## Contributing
 
@@ -651,12 +810,19 @@ The persistence logic is decoupled from the implementation, so it is possible to
 5. Create new Pull Request
 
 ## License
+
 MIT Copyright (c) 2014 Chris Stefano
 
 Portions of code are from the Sidekiq project, Copyright (c) Contributed Systems LLC.
 
 ## Inspiration
 
-Inspired by the [sidekiq](https://github.com/mperham/sidekiq) and [workflow](https://github.com/geekq/workflow) gems.
+Inspired by the [sidekiq](https://github.com/mperham/sidekiq) and
+[workflow](https://github.com/geekq/workflow) gems.
+
+For other workflow solutions, checkout [Stonepath](https://github.com/bokmann/stonepath),
+the now deprecated [ruote](https://github.com/jmettraux/ruote) gem and
+[workflow](https://github.com/geekq/workflow).
 
-For other workflow solutions, checkout [Stonepath](https://github.com/bokmann/stonepath), the now deprecated [ruote](https://github.com/jmettraux/ruote) gem and [workflow](https://github.com/geekq/workflow). Alternatively, for a robust enterprise ready solution checkout the [AWS Flow Framework for Ruby](http://docs.aws.amazon.com/amazonswf/latest/awsrbflowguide/welcome.html).
+Alternatively, for a robust enterprise ready solution checkout the
+[AWS Flow Framework for Ruby](http://docs.aws.amazon.com/amazonswf/latest/awsrbflowguide/welcome.html).

data/lib/taskinator/api.rb

@@ -13,12 +13,13 @@ module Taskinator
       def each(&block)
         return to_enum(__method__) unless block_given?
 
+        identifiers = Taskinator.redis do |conn|
+          conn.smembers(@processes_list_key)
+        end
+
         instance_cache = {}
-        Taskinator.redis do |conn|
-          uuids = conn.smembers(@processes_list_key)
-          uuids.each do |uuid|
-            yield Process.fetch(uuid, instance_cache)
-          end
+        identifiers.each do |identifier|
+          yield Process.fetch(identifier, instance_cache)
         end
       end
 
@@ -28,5 +29,13 @@ module Taskinator
         end
       end
     end
+
+    def self.find_process(identifier)
+      Process.fetch(identifier)
+    end
+
+    def self.find_task(identifier)
+      Task.fetch(identifier)
+    end
   end
 end

data/lib/taskinator/queues/active_job.rb

@@ -0,0 +1,53 @@
+module Taskinator
+  module Queues
+
+    # https://guides.rubyonrails.org/active_job_basics.html
+
+    def self.create_active_job_adapter(config={})
+      ActiveJobAdapter.new(config)
+    end
+
+    class ActiveJobAdapter
+      def initialize(config={})
+        @config = Taskinator::Queues::DefaultConfig.merge(config)
+      end
+
+      def enqueue_create_process(definition, uuid, args)
+        queue = definition.queue || @config[:definition_queue]
+        CreateProcessWorker.set(:queue => queue)
+          .perform_later(definition.name, uuid, Taskinator::Persistence.serialize(args))
+      end
+
+      def enqueue_process(process)
+        queue = process.queue || @config[:process_queue]
+        ProcessWorker.set(:queue => queue)
+          .perform_later(process.uuid)
+      end
+
+      def enqueue_task(task)
+        queue = task.queue || @config[:task_queue]
+        TaskWorker.set(:queue => queue)
+          .perform_later(task.uuid)
+      end
+
+      class CreateProcessWorker < ApplicationJob
+        def perform(definition_name, uuid, args)
+          Taskinator::CreateProcessWorker.new(definition_name, uuid, args).perform
+        end
+      end
+
+      class ProcessWorker < ApplicationJob
+        def perform(process_uuid)
+          Taskinator::ProcessWorker.new(process_uuid).perform
+        end
+      end
+
+      class TaskWorker < ApplicationJob
+        def perform(task_uuid)
+          Taskinator::TaskWorker.new(task_uuid).perform
+        end
+      end
+
+    end
+  end
+end

data/lib/taskinator/queues.rb

@@ -48,6 +48,7 @@ module Taskinator
   end
 end
 
+require 'taskinator/queues/active_job' if defined?(ApplicationJob)
 require 'taskinator/queues/delayed_job' if defined?(Delayed)
 require 'taskinator/queues/resque' if defined?(Resque)
 require 'taskinator/queues/sidekiq' if defined?(Sidekiq)

data/lib/taskinator/version.rb

@@ -1,3 +1,3 @@
 module Taskinator
-  VERSION = "0.4.2"
+  VERSION = "0.4.6"
 end

data/lib/taskinator.rb

@@ -98,7 +98,7 @@ module Taskinator
 
     # the queue adapter to use
     # supported adapters include
-    # :delayed_job, :redis and :sidekiq
+    # :active_job, :delayed_job, :redis and :sidekiq
     # NOTE: ensure that the respective gem is included
     attr_reader :queue_adapter
 
@@ -118,7 +118,7 @@ module Taskinator
 
     def queue
       @queue ||= begin
-        adapter = self.queue_adapter || :resque
+        adapter = self.queue_adapter || :resque  # TODO: change default to :active_job
         config = queue_config || {}
         Taskinator::Queues.create_adapter(adapter, config)
       end