async_task 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ee19b9b762966a602d9963bff309cabe1b4e46d0
+  data.tar.gz: 5cb5522d5eb98fb0b6a6d0fb60d93a31b686ea0d
+SHA512:
+  metadata.gz: 425b2c7a2a788a16b96805d342be67029b7c20b3c6f06ee55d3b84d8e2b0ddb1164be05c5b29bd6ef7dbbc7f4491d4f9a0b1d71ca3efc1159e87b0e37376f0bb
+  data.tar.gz: ca8c5f65e7fe98c2841740a2f49499790e33faa0a9658847704fa1dc230ec112b86aad582e6c5fa8b603b02e7ccfba4131c109e2987e77c43d64770fdeb548a8

data/.gitignore

@@ -0,0 +1,19 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# Ignore all logfiles and tempfiles
+*.log
+*.swp
+
+# Ignore all sqlite3 files
+*.sqlite3
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,29 @@
+Lint/AmbiguousBlockAssociation:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Security/YAMLLoad:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/CHANGES.md

@@ -0,0 +1,3 @@
+### 0.0.1 / 2017-12-04
+
+* Initial release

data/Gemfile

@@ -0,0 +1,22 @@
+source 'https://rubygems.org'
+
+gemspec
+
+# Core
+gem 'bundler', '~> 1.14'
+gem 'rake', '~> 11.0'
+
+# Development Experience
+gem 'pry'
+gem 'pry-byebug'
+gem 'rubocop'
+
+# Testing (see spec/dummy)
+gem 'factory_bot'
+gem 'rails', '~> 5.1.0'
+gem 'rspec', '~> 3.5'
+gem 'rspec-rails', '~> 3.0'
+gem 'sq-protos'
+gem 'sqlite3'
+
+gem 'timecop'

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2017 Square, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,202 @@
+# AsyncTask
+
+Lightweight, asynchronous, and database-backed execution of singleton methods.
+
+This gem provides generators and mixins to queue up tasks in database transactions to be performed
+later. Doing so prevents (1) tasks from being run twice if performed within a transaction and (2)
+tasks from synchronously blocking.
+
+```ruby
+transaction do
+  order = Order.create!(number: 7355608)
+
+  # RPC Call
+  OrderClient.fulfill(customer_token: customer_token, order_number: order.number)
+
+  raise
+end
+```
+
+Despite database transaction rolling back the creation of the `Order` record, the RPC call executes.
+This problem becomes more difficult in nested transactions. To avoid doing something regrettable, we
+create an `AsyncTask::Attempt` record inside the database. These records are then performed at a
+later time using a job:
+
+```ruby
+transaction do
+  order = Order.create!(number: 1)
+
+  # To be performed by a job later
+  AsyncTask::Attempt.create!(
+    target: OrderClient,
+    method_name: :fulfill,
+    method_args: { customer_token: customer_token, order_number: order.number },
+  )
+
+  raise
+end
+```
+
+The above pattern ensures we will not act when there is a rollback later in the transaction.
+
+The gem provides the following:
+
+* Models
+  * Generators for the `AsyncTask::Attempt` migration, model, factory, and specs.
+  * Choice between using async tasks with encrypted or unencrypted method arguments.
+  * Tracking completion using `completed_at`.
+  * Fields for `target`, `method_name`, and `method_args`.
+  * `AsyncTask::BaseAttempt` mixin to provide model methods.
+  * A `num_attempts` field gives you flexibility to handle retries and other failure scenarios.
+  * `status` and `completed_at` are fields that track state.
+  * `idempotence_token` field for rolling your own presence, uniqueness, or idempotence checks.
+
+* Jobs
+  * Generators for `AsyncTask::AttemptJob`, `AsyncTask::AttemptBatchJob`, and their specs.
+  * `AsyncTask::BaseAttemptJob` and `AsyncTask::BaseAttemptBatchJob` mixins.
+
+## Getting Started
+
+1. Add the gem to your application's Gemfile and execute `bundle install` to install it:
+
+```ruby
+gem 'async_task'
+```
+
+2. Generate migrations, base models, jobs, and specs. Feel free to add any additional columns you
+need to the generated migration file:
+
+`$ rails g async_task:install`
+
+3. Rename the model and migrations as you see fit. Make sure your model contains
+`include AsyncTask::BaseAttempt`. Use `self.table_name=` if necessary.
+
+```ruby
+class AsyncTask::Attempt < ApplicationRecord
+  include AsyncTask::BaseAttempt
+end
+```
+
+4. Implement the `handle_perform_error` in your `AsyncTask::Attempt` model. This methods is used by
+`AsyncTask::BaseAttempt` when exceptions are thrown performing the task.
+
+5. This gem provides no encryptor by default. Implement an encryptor (see below) if you need
+encrypted params.
+
+6. Create `AsyncTask::Attempt`s to be sent later by a job (generated) that includes a
+`AsyncTask::BaseAttemptJob`:
+
+```ruby
+class AsyncTask::AttemptJob < ActiveJob::Base
+  include AsyncTask::BaseAttemptJob
+end
+```
+
+```ruby
+AsyncTask::Attempt.create!(
+  target: OrderClient,
+  method_name: :fulfill,
+  method_args: { customer_token: customer_token, order_number: order.number },
+)
+```
+
+7. **Make sure to schedule the `AsyncTask::AttemptJob` to run frequently using something like [`Clockwork`](https://github.com/adamwiggins/clockwork).**
+
+## Cautionary Situations When Using This Gem
+
+### Task Idempotence
+
+The `target`, `method_name`, and `method_args` should be idempotent because the
+`AsyncTask::AttemptBatchJob` could schedule multiple `AsyncTask::AttemptJob`s if the job queue is
+backed up.
+
+### Nested Transactions
+
+Task execution occurs inside of a `with_lock` block, which executes the body inside of a database
+transaction. Keep in mind that transactions inside the `#{target}.#{method_name}` will be nested.
+You may have to consider implementing `transaction(require: new)` or creating transactions in
+separate threads.
+
+## Cookbook
+
+### Custom Encryptors
+
+Implement the interface present in `AsyncTask::NullEncryptor` to provide your own encryptor.
+
+```ruby
+module AesEncryptor
+  extend self
+
+  def decrypt(content)
+    AesClient.decrypt(content)
+  end
+
+  def encrypt(content)
+    AesClient.encrypt(content)
+  end
+end
+```
+
+### Delayed Execution
+
+Setting the `scheduled_at` field allows delayed execution to be possible. A task that has an
+`scheduled_at` before `Time.current` will be executed by `AsyncTask::BaseAttemptBatchJob`.
+
+### Handling AsyncTask::BaseAttempt Errors
+
+```ruby
+class AsyncTask::Attempt < ActiveRecord::Base
+  include AsyncTask::BaseAttempt
+
+  def handle_perform_error(error)
+    Raven.capture_exception(error)
+  end
+end
+```
+
+Lastly, the `num_attempts` field in `AsyncTask::Attempt` allows you to track the number of attempts
+the task has undergone. Use this to implement retries and permanent failure thresholds for your
+tasks.
+
+### Proper Usage of `expire!` / `fail!`
+
+`expire!` should be used for tasks that should no longer be run.
+
+`fail!` should be used to mark permanent failure for a task.
+
+## Design Motivations
+
+We're relying heavily on generators and mixins. Including the `AsyncTask::BaseAttempt` module allows
+us to generate a model that can inherit from both `ActiveRecord::Base` (Rails 4) and
+`ApplicationRecord` (Rails 5). The `BaseAttempt` module's methods can easily be overridden, giving
+callers flexibility to handle errors, extend functionality, and inherit (STI). Lastly, the generated
+migrations provide fields used by the `BaseAttempt` module, but the developer is free to add their
+own fields and extend the module's methods while calling `super`.
+
+## Development
+
+* Install dependencies with `bin/setup`.
+* Run tests/lints with `rake`
+* For an interactive prompt that will allow you to experiment, run `bin/console`.
+
+## Acknowledgments
+
+* [RickCSong](https://github.com/RickCSong)
+
+## License
+
+```
+Copyright 2017 Square, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/setup'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task default: %w[spec rubocop]

data/async_task.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'async_task/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'async_task'
+  spec.version       = AsyncTask::VERSION
+  spec.authors       = ['James Chang']
+  spec.email         = ['jchang@squareup.com']
+
+  spec.summary       = 'Lightweight, asynchronous, and database-backed execution of singleton methods.'
+  spec.homepage      = 'https://github.com/square/async_task'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.executables = spec.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.3'
+
+  spec.add_runtime_dependency 'activejob', '>= 4.2.0', '< 5.2'
+  spec.add_runtime_dependency 'activerecord', '>= 4.2.0', '< 5.2'
+  spec.add_runtime_dependency 'activesupport', '>= 4.2.0', '< 5.2'
+
+  spec.add_runtime_dependency 'enumerize'
+  spec.add_runtime_dependency 'with_advisory_lock'
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'async_task'
+
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/async_task.rb

@@ -0,0 +1,13 @@
+require 'active_job'
+require 'active_record'
+require 'active_support'
+require 'active_support/core_ext'
+require 'enumerize'
+require 'with_advisory_lock'
+
+require 'async_task/version'
+
+require 'async_task/base_attempt'
+require 'async_task/null_encryptor'
+
+Dir["#{File.dirname(__FILE__)}/async_task/jobs/**/*.rb"].each { |file| require file }

data/lib/async_task/base_attempt.rb

@@ -0,0 +1,102 @@
+module AsyncTask
+  class InvalidStateError < StandardError; end
+
+  module BaseAttempt
+    extend ActiveSupport::Concern
+
+    included do
+      extend Enumerize
+
+      self.table_name = 'async_task_attempts'
+
+      attr_readonly :idempotence_token
+      attr_readonly :target
+      attr_readonly :method_name
+      attr_readonly :method_args
+      attr_readonly :encryptor
+
+      validates :target, presence: true
+      validates :method_name, presence: true
+      validates :encryptor, presence: true
+
+      serialize :method_args
+
+      enumerize :status,
+                in: %i[pending succeeded failed expired],
+                predicates: true
+
+      scope :pending, -> { where(status: :pending) }
+      scope :succeeded, -> { where(status: :succeeded) }
+      scope :failed, -> { where(status: :failed) }
+      scope :expired, -> { where(status: :expired) }
+
+      before_create do
+        self.target = target.to_s
+        self.status ||= 'pending'
+        self.encryptor = (encryptor.presence || AsyncTask::NullEncryptor).to_s
+      end
+
+      def method_args
+        return if super.blank?
+        YAML.load(encryptor.constantize.decrypt(super))
+      end
+
+      def method_args=(args)
+        super(encryptor.constantize.encrypt(args.to_yaml))
+      end
+    end
+
+    def perform!
+      return unless may_schedule?
+
+      begin
+        reload
+        raise AsyncTask::InvalidStateError unless pending?
+        increment!(:num_attempts)
+      rescue ActiveRecord::StaleObjectError
+        retry
+      end
+
+      with_lock do
+        raise AsyncTask::InvalidStateError unless pending?
+
+        if method_args.present?
+          target.constantize.__send__(method_name, **method_args)
+        else
+          target.constantize.__send__(method_name)
+        end
+
+        update_status!('succeeded')
+      end
+    rescue StandardError => e
+      handle_perform_error(e)
+    end
+
+    def expire!
+      with_lock do
+        raise AsyncTask::InvalidStateError unless pending?
+        update_status!('expired')
+      end
+    end
+
+    def fail!
+      with_lock do
+        raise AsyncTask::InvalidStateError unless pending?
+        update_status!('failed')
+      end
+    end
+
+    def may_schedule?
+      scheduled_at.blank? || scheduled_at < Time.current
+    end
+
+    private
+
+    # Does nothing, override this.
+    def handle_perform_error(_e); end
+
+    def update_status!(status)
+      update!(status: status, completed_at: Time.current)
+    end
+  end
+end

data/lib/async_task/jobs/base_attempt_batch_job.rb

@@ -0,0 +1,19 @@
+module AsyncTask
+  module BaseAttemptBatchJob
+    extend ActiveSupport::Concern
+
+    included do
+      include BaseJob
+
+      queue_as :default
+    end
+
+    def perform
+      unless_already_executing do
+        ::AsyncTask::Attempt.pending.where('scheduled_at IS ? OR scheduled_at < ?', nil, Time.current).find_each do |task|
+          ::AsyncTask::AttemptJob.perform_later(task)
+        end
+      end
+    end
+  end
+end

data/lib/async_task/jobs/base_attempt_job.rb

@@ -0,0 +1,21 @@
+module AsyncTask
+  module BaseAttemptJob
+    extend ActiveSupport::Concern
+
+    included do
+      include BaseJob
+
+      queue_as :default
+
+      # @override
+      private def lock_key
+        [self.class.name, @task.id]
+      end
+    end
+
+    def perform(task)
+      @task = task
+      unless_already_executing { @task.perform! if @task.reload.pending? }
+    end
+  end
+end

data/lib/async_task/jobs/base_job.rb

@@ -0,0 +1,16 @@
+module AsyncTask
+  module BaseJob
+    extend ActiveSupport::Concern
+
+    private
+
+    def lock_key
+      self.class.name
+    end
+
+    def unless_already_executing(&block)
+      result = ActiveRecord::Base.with_advisory_lock_result(lock_key, timeout_seconds: 0, &block)
+      warn("AdvisoryLock owned by other instance of job: #{lock_key}. Exiting.") unless result.lock_was_acquired?
+    end
+  end
+end

data/lib/async_task/null_encryptor.rb

@@ -0,0 +1,13 @@
+module AsyncTask
+  module NullEncryptor
+    module_function
+
+    def decrypt(content)
+      content
+    end
+
+    def encrypt(content)
+      content
+    end
+  end
+end

data/lib/async_task/version.rb

@@ -0,0 +1,3 @@
+module AsyncTask
+  VERSION = '0.0.1'
+end

data/lib/generators/async_task/install_generator.rb

@@ -0,0 +1,37 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module AsyncTask
+  class InstallGenerator < ::Rails::Generators::Base
+    include ::Rails::Generators::Migration
+
+    source_root File.expand_path('../templates/', __FILE__)
+
+    desc 'Generates (but does not run) migrations to add the' \
+         ' async_tasks table and creates the base model'
+
+    def self.next_migration_number(dirname)
+      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    def create_migration_file
+      migration_template 'create_async_task_attempts.rb', 'db/migrate/create_async_task_attempts.rb'
+    end
+
+    def create_async_task_files
+      template 'async_task_attempt.rb.erb', 'app/models/async_task/attempt.rb'
+      template 'async_task_attempt_job.rb.erb', 'app/jobs/async_task/attempt_job.rb'
+      template 'async_task_attempt_batch_job.rb.erb', 'app/jobs/async_task/attempt_batch_job.rb'
+
+      if defined?(RSpec)
+        template 'async_task_attempt_spec.rb.erb', 'spec/models/async_task/attempt_spec.rb'
+        template 'async_task_attempt_job_spec.rb.erb', 'spec/jobs/async_task/attempt_job_spec.rb'
+        template 'async_task_attempt_batch_job_spec.rb.erb', 'spec/jobs/async_task/attempt_batch_job_spec.rb'
+      end
+
+      if defined?(FactoryBot) || defined?(FactoryGirl)
+        template 'async_task_attempts.rb.erb', 'spec/factories/async_task/attempts.rb'
+      end
+    end
+  end
+end

data/lib/generators/async_task/templates/async_task_attempt.rb.erb

@@ -0,0 +1,10 @@
+class AsyncTask::Attempt < <% if Rails::VERSION::STRING >= '5' %>ApplicationRecord<% else %>ActiveRecord::Base<% end %>
+  include AsyncTask::BaseAttempt
+
+  # @override
+  #
+  # This method is used by AsyncTask::Base when #perform! fails.
+  def handle_perform_error(error)
+    Raven.capture_exception(error)
+  end
+end

data/lib/generators/async_task/templates/async_task_attempt_batch_job.rb.erb

@@ -0,0 +1,3 @@
+class AsyncTask::AttemptBatchJob < <% if Rails::VERSION::STRING >= '5' %>ApplicationJob<% else %>ActiveJob::Base<% end %>
+  include AsyncTask::BaseAttemptBatchJob
+end

data/lib/generators/async_task/templates/async_task_attempt_batch_job_spec.rb.erb

@@ -0,0 +1,5 @@
+require 'rails_helper'
+
+RSpec.describe AsyncTask::AttemptBatchJob, type: :job do
+  pending "add some examples to (or delete) #{__FILE__}"
+end

data/lib/generators/async_task/templates/async_task_attempt_job.rb.erb

@@ -0,0 +1,3 @@
+class AsyncTask::AttemptJob < <% if Rails::VERSION::STRING >= '5' %>ApplicationJob<% else %>ActiveJob::Base<% end %>
+  include AsyncTask::BaseAttemptJob
+end

data/lib/generators/async_task/templates/async_task_attempt_job_spec.rb.erb

@@ -0,0 +1,5 @@
+require 'rails_helper'
+
+RSpec.describe AsyncTask::AttemptJob, type: :job do
+  pending "add some examples to (or delete) #{__FILE__}"
+end

data/lib/generators/async_task/templates/async_task_attempt_spec.rb.erb

@@ -0,0 +1,5 @@
+require 'rails_helper'
+
+RSpec.describe AsyncTask::Attempt, type: :model do
+  pending "add some examples to (or delete) #{__FILE__}"
+end

data/lib/generators/async_task/templates/async_task_attempts.rb.erb

@@ -0,0 +1,21 @@
+<% if defined?(FactoryBot) %>FactoryBot<% else %>FactoryGirl<%end%>.define do
+  factory :async_task_attempt, class: 'AsyncTask::Attempt' do
+    status { 'pending' }
+    encryptor { AsyncTask::NullEncryptor }
+
+    trait :succeeded do
+      status { :succeeded }
+      completed_at { Time.current }
+    end
+
+    trait :expired do
+      status { 'expired' }
+      completed_at { Time.current }
+    end
+
+    trait :failed do
+      status { 'failed' }
+      completed_at { Time.current }
+    end
+  end
+end

data/lib/generators/async_task/templates/create_async_task_attempts.rb

@@ -0,0 +1,33 @@
+class CreateAsyncTaskAttempts < ActiveRecord::Migration[5.1]
+  def change
+    create_table :async_task_attempts do |t|
+      t.integer       :lock_version, null: false, default: 0
+
+      t.string        :idempotence_token
+
+      t.string        :status, null: false
+
+      t.string        :target, null: false
+      t.string        :method_name, null: false
+      t.text          :method_args
+
+      t.string        :encryptor, null: false
+
+      t.integer       :num_attempts, null: false, default: 0
+
+      t.datetime      :scheduled_at
+      t.datetime      :completed_at
+
+      t.timestamps    null: false
+
+      t.index :status
+
+      t.index %i[target method_name idempotence_token], unique: true, name: 'index_async_tasks_on_target_method_name_and_idempotence_token'
+
+      t.index :scheduled_at
+      t.index :completed_at
+      t.index :created_at
+      t.index :updated_at
+    end
+  end
+end

data/script/ci

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+set -eux -o pipefail
+
+REQUIRED_BUNDLER_VERSION="~> 1.14.3"
+
+function update_rubygems() {
+  gem update --system
+}
+
+function install_bundler() {
+  gem install bundler --conservative --version "$REQUIRED_BUNDLER_VERSION"
+}
+
+function install_gems() {
+  bundle check || bundle
+}
+
+function run_rake() {
+  bundle exec rake
+}
+
+update_rubygems &&
+install_bundler &&
+install_gems &&
+run_rake

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: async_task
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- James Chang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: enumerize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: with_advisory_lock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- jchang@squareup.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGES.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- async_task.gemspec
+- bin/console
+- bin/setup
+- lib/async_task.rb
+- lib/async_task/base_attempt.rb
+- lib/async_task/jobs/base_attempt_batch_job.rb
+- lib/async_task/jobs/base_attempt_job.rb
+- lib/async_task/jobs/base_job.rb
+- lib/async_task/null_encryptor.rb
+- lib/async_task/version.rb
+- lib/generators/async_task/install_generator.rb
+- lib/generators/async_task/templates/async_task_attempt.rb.erb
+- lib/generators/async_task/templates/async_task_attempt_batch_job.rb.erb
+- lib/generators/async_task/templates/async_task_attempt_batch_job_spec.rb.erb
+- lib/generators/async_task/templates/async_task_attempt_job.rb.erb
+- lib/generators/async_task/templates/async_task_attempt_job_spec.rb.erb
+- lib/generators/async_task/templates/async_task_attempt_spec.rb.erb
+- lib/generators/async_task/templates/async_task_attempts.rb.erb
+- lib/generators/async_task/templates/create_async_task_attempts.rb
+- script/ci
+homepage: https://github.com/square/async_task
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Lightweight, asynchronous, and database-backed execution of singleton methods.
+test_files: []