acidic_job 0.3.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8aa8aee9c23bc58be992813f139864afdb057442ee9c359263f3ff45029e3f28
-  data.tar.gz: 9dbb8017fcbf91ce5cbcc5c96968e3b880340c1e1cc7a8c36cb11e744d6b405d
+  metadata.gz: 7b6e76d892b0953452781a38155801969acf50d81897fb78645b561280620ddc
+  data.tar.gz: 6640c17792135307d21d20f05b49136512368ff84ed748fb2b1ad98d552fc8fb
 SHA512:
-  metadata.gz: 4bb2298f924a2aa2d5db31c7c05201188872333c36dd3e0bafb598ed087ec9a686695c27b1cdd2d33f067f2bbb47178c5bc700201406db856392997ef6605dbc
-  data.tar.gz: f842586dc2d669196ce58bcbc279bc2b967fd0c8973d296323622c993e8d08422ce65f55b85cf96407aa4a668af15dea005fdf3f8917e520ca020c2851dd4bfa
+  metadata.gz: c489d047845c6fcd27482dfe1a3c0cae89a326cd3c81d4816ca9758c7db9e0edd09d954e719eedcc0d8b2a689137e21486482571bd05b7518af795152fc4bc61
+  data.tar.gz: ddc07f0514be3ad3f8fdec4ffd4bf350a039a4ad95f6b28984f1cb73f29d51ed3511df94eb628f8f336b81d4edae3d9b1c9af3a8b55ab5ac08efc015775c9249

data/.rubocop.yml

@@ -12,3 +12,6 @@ Style/StringLiteralsInInterpolation:
 
 Layout/LineLength:
   Max: 120
+
+Style/Documentation:
+  Enabled: false

data/Gemfile

@@ -26,3 +26,5 @@ gem "database_cleaner"
 gem "simplecov"
 
 gem "pry"
+
+gem "sidekiq"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    acidic_job (0.3.1)
+    acidic_job (0.5.2)
       activerecord (>= 4.0.0)
       activesupport
 
@@ -39,6 +39,7 @@ GEM
     builder (3.2.4)
     coderay (1.1.3)
     concurrent-ruby (1.1.9)
+    connection_pool (2.2.5)
     crass (1.0.6)
     database_cleaner (2.0.1)
       database_cleaner-active_record (~> 2.0.0)
@@ -86,6 +87,7 @@ GEM
       thor (~> 1.0)
     rainbow (3.0.0)
     rake (13.0.4)
+    redis (4.4.0)
     regexp_parser (2.1.1)
     rexml (3.2.5)
     rubocop (1.18.3)
@@ -104,6 +106,10 @@ GEM
     rubocop-rake (0.6.0)
       rubocop (~> 1.0)
     ruby-progressbar (1.11.0)
+    sidekiq (6.2.2)
+      connection_pool (>= 2.2.2)
+      rack (~> 2.0)
+      redis (>= 4.2.0)
     simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
@@ -133,6 +139,7 @@ DEPENDENCIES
   rubocop (~> 1.7)
   rubocop-minitest
   rubocop-rake
+  sidekiq
   simplecov
   sqlite3
 

data/acidic_job.gemspec

@@ -27,8 +27,8 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport"
   spec.add_dependency "activerecord", ">= 4.0.0"
+  spec.add_dependency "activesupport"
   spec.add_development_dependency "railties", ">= 4.0"
 
   # For more information and examples about making a new gem, checkout our

data/blog_post.md

@@ -0,0 +1,28 @@
+# ACIDic Operations in Rails
+
+At the conceptual heart of basically any software are "operations"—the discrete actions the software performs. At the horizon of basically any software is the goal to make that sofware _robust_. Typically, one makes a software system robust by making each of its operations robust. Moreover, typically, robustness in software is considered as the software being "ACIDic"—atomic, consistent, isolated, durable.
+
+In a loosely collected series of articles, Brandur Leach lays out the core techniques and principles required to make an HTTP API properly ACIDic:
+
+1. https://brandur.org/acid
+2. https://brandur.org/http-transactions
+3. https://brandur.org/job-drain
+4. https://brandur.org/idempotency-keys
+
+With these techniques and principles in mind, our challenge is bring them into the world of a standard Rails application. This will require us to conceptually map the concepts of an HTTP request, an API server action, and an HTTP response into the world of a running Rails process.
+
+We can begin to make this mapping by observing that an API server action is a specific instantiation of the general concept of an "operation". Like all operations, it has a "trigger" (the HTTP request) and a "response" (the HTTP response). So, what we need is a foundation upon which to build our Rails "operations".
+
+In order to help us find that tool, let us consider the necessary characteristics we need. We need something that we can easily trigger from other Ruby code throughout our Rails application (controller actions, model methods, model callbacks, etc.). It should also be able to be run both synchronously (blocking execution and then returning its response to the caller) and asychronously (non-blocking and the caller doesn't know its response). It should then also be able to retry a specific operation (in much the way that an API consumer can "retry an operation" by hitting the same endpoint with the same request). 
+
+As we lay out these characteristics, I imagine your mind is going where mine went—`ActiveJob` gives us a solid foundation upon which we can build "ACIDic" operations.
+
+So, our challenge to build tooling which will allow us to make "operational" jobs _robust_.
+
+What we need primarily is to be able to make our jobs *idempotent*, and one of the simplest yet still most powerful tools for making an operation idempotent is the idempotency key. As laid out in the article linked above, an idempotency key is a record that we store in our database to uniquely identify a particular execution of an operation and a related "recovery point" for where we are in the process of that operation.
+
+
+
+
+
+

data/lib/acidic_job/errors.rb

@@ -0,0 +1,15 @@
+module AcidicJob
+  class Error < StandardError; end
+
+  class MismatchedIdempotencyKeyAndJobArguments < Error; end
+
+  class LockedIdempotencyKey < Error; end
+
+  class UnknownRecoveryPoint < Error; end
+
+  class UnknownAtomicPhaseType < Error; end
+
+  class SerializedTransactionConflict < Error; end
+
+  class UnknownJobAdapter < Error; end
+end

data/lib/acidic_job/key.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module AcidicJob
+  class Key < ActiveRecord::Base
+    RECOVERY_POINT_FINISHED = "FINISHED"
+
+    self.table_name = "acidic_job_keys"
+
+    serialize :error_object
+    serialize :job_args
+
+    validates :idempotency_key, presence: true, uniqueness: { scope: %i[job_name job_args] }
+    validates :job_name, presence: true
+    validates :last_run_at, presence: true
+    validates :recovery_point, presence: true
+
+    def finished?
+      recovery_point == RECOVERY_POINT_FINISHED
+    end
+
+    def succeeded?
+      finished? && !failed?
+    end
+
+    def failed?
+      error_object.present?
+    end
+  end
+end

data/lib/acidic_job/perform_transactionally_extension.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module AcidicJob
+  module PerformTransactionallyExtension
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def perform_transactionally(*args)
+        attributes = if self < ActiveJob::Base
+          {
+            adapter: "activejob",
+            job_name: self.name,
+            job_args: job_or_instantiate(*args).serialize
+          }
+        elsif self.include? Sidekiq::Worker
+          {
+            adapter: "sidekiq",
+            job_name: self.name,
+            job_args: args
+          }
+        else
+          raise UnknownJobAdapter
+        end
+
+        AcidicJob::Staged.create!(attributes)
+      end
+    end
+  end
+end

data/lib/acidic_job/perform_wrapper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module AcidicJob
+  module PerformWrapper
+    def perform(*args, **kwargs)
+      # store arguments passed into `perform` so that we can later persist
+      # them to `AcidicJob::Key#job_args` for both ActiveJob and Sidekiq::Worker
+      @arguments_for_perform = if args.any? && kwargs.any?
+        args + [kwargs]
+      elsif args.any? && kwargs.none?
+        args
+      elsif args.none? && kwargs.any?
+        [kwargs]
+      else
+        []
+      end
+
+      super
+    end
+  end
+end

data/lib/acidic_job/recovery_point.rb

@@ -11,6 +11,7 @@ module AcidicJob
     end
 
     def call(key:)
+      # Skip AR callbacks as there are none on the model
       key.update_column(:recovery_point, name)
     end
   end

data/lib/acidic_job/response.rb

@@ -6,7 +6,8 @@
 module AcidicJob
   class Response
     def call(key:)
-      key.update!(
+      # Skip AR callbacks as there are none on the model
+      key.update_columns(
         locked_at: nil,
         recovery_point: Key::RECOVERY_POINT_FINISHED
       )

data/lib/acidic_job/staged.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module AcidicJob
+  class Staged < ActiveRecord::Base
+    self.table_name = "staged_acidic_jobs"
+
+    validates :adapter, presence: true
+    validates :job_name, presence: true
+    validates :job_args, presence: true
+
+    serialize :job_args
+
+    after_create_commit :enqueue_job
+
+    def enqueue_job
+      if adapter == "activejob"
+        job = ActiveJob::Base.deserialize(job_args)
+        job.enqueue
+      elsif adapter == "sidekiq"
+        Sidekiq::Client.push("class" => job_name, "args" => job_args)
+      else
+        raise UnknownJobAdapter.new(adapter: adapter)
+      end
+
+      # TODO: ensure successful enqueuing before deletion
+      delete
+    end
+  end
+end

data/lib/acidic_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AcidicJob
-  VERSION = "0.3.1"
+  VERSION = "0.5.2"
 end

data/lib/acidic_job.rb

@@ -1,60 +1,39 @@
 # frozen_string_literal: true
 
 require_relative "acidic_job/version"
+require_relative "acidic_job/errors"
 require_relative "acidic_job/no_op"
 require_relative "acidic_job/recovery_point"
 require_relative "acidic_job/response"
+require_relative "acidic_job/key"
+require_relative "acidic_job/staged"
+require_relative "acidic_job/perform_wrapper"
+require_relative "acidic_job/perform_transactionally_extension"
 require "active_support/concern"
 
-# rubocop:disable Metrics/ModuleLength, Style/Documentation, Metrics/AbcSize, Metrics/MethodLength
+# rubocop:disable Metrics/ModuleLength, Metrics/AbcSize, Metrics/MethodLength
 module AcidicJob
-  class MismatchedIdempotencyKeyAndJobArguments < StandardError; end
-
-  class LockedIdempotencyKey < StandardError; end
-
-  class UnknownRecoveryPoint < StandardError; end
-
-  class UnknownAtomicPhaseType < StandardError; end
-
-  class SerializedTransactionConflict < StandardError; end
-
-  class Key < ActiveRecord::Base
-    RECOVERY_POINT_FINISHED = "FINISHED"
-
-    self.table_name = "acidic_job_keys"
-
-    serialize :error_object
-    serialize :job_args
-
-    validates :idempotency_key, presence: true, uniqueness: {scope: [:job_name, :job_args]}
-    validates :job_name, presence: true
-    validates :last_run_at, presence: true
-    validates :recovery_point, presence: true
+  extend ActiveSupport::Concern
 
-    def finished?
-      recovery_point == RECOVERY_POINT_FINISHED
-    end
+  def self.wire_everything_up(klass)
+    klass.attr_reader :key
+    klass.attr_accessor :arguments_for_perform
 
-    def succeeded?
-      finished? && !failed?
-    end
+    # Extend ActiveJob with `perform_transactionally` class method
+    klass.include PerformTransactionallyExtension
 
-    def failed?
-      error_object.present?
-    end
+    # Ensure our `perform` method always runs first to gather parameters
+    klass.prepend PerformWrapper
   end
 
-  extend ActiveSupport::Concern
-
   included do
-    attr_reader :key
-
-    # discard_on MismatchedIdempotencyKeyAndJobArguments
-    # discard_on UnknownRecoveryPoint
-    # discard_on UnknownAtomicPhaseType
-    # discard_on MissingRequiredAttribute
-    # retry_on LockedIdempotencyKey
-    # retry_on ActiveRecord::SerializationFailure
+    AcidicJob.wire_everything_up(self)
+  end
+
+  class_methods do
+    def inherited(subclass)
+      AcidicJob.wire_everything_up(subclass)
+    end
   end
 
   # Number of seconds passed which we consider a held idempotency key lock to be
@@ -63,8 +42,8 @@ module AcidicJob
   # this might not happen 100% of the time, so this is a hedge against it.
   IDEMPOTENCY_KEY_LOCK_TIMEOUT = 90
 
-  # &block
-  def idempotently(with:) # &block
+  # takes a block
+  def idempotently(with:)
     # set accessors for each argument passed in to ensure they are available
     # to the step methods the job will have written
     define_accessors_for_passed_arguments(with)
@@ -84,13 +63,13 @@ module AcidicJob
     # close proximity, one of the two will be aborted by Postgres because we're
     # using a transaction with SERIALIZABLE isolation level. It may not look
     # it, but this code is safe from races.
-    ensure_idempotency_key_record(job_id, defined_steps.first)
+    ensure_idempotency_key_record(idempotency_key_value, defined_steps.first)
 
     # if the key record is already marked as finished, immediately return its result
     return @key.succeeded? if @key.finished?
 
     # otherwise, we will enter a loop to process each required step of the job
-    100.times do
+    phases.size.times do
       # our `phases` hash uses Symbols for keys
       recovery_point = @key.recovery_point.to_sym
 
@@ -114,10 +93,16 @@ module AcidicJob
     @_steps
   end
 
+  def safely_finish_acidic_job
+    # Short circuits execution by sending execution right to 'finished'.
+    # So, ends the job "successfully"
+    AcidicJob::Response.new
+  end
+
   private
 
   def atomic_phase(key, proc = nil, &block)
-    error = false
+    rescued_error = false
     phase_callable = (proc || block)
 
     begin
@@ -126,15 +111,17 @@ module AcidicJob
 
         phase_result.call(key: key)
       end
-    rescue => e
-      error = e
+    rescue StandardError => e
+      rescued_error = e
       raise e
     ensure
+      return unless rescued_error
+
       # If we're leaving under an error condition, try to unlock the idempotency
-      # key right away so that another request can try again.
+      # key right away so that another request can try again.3
       begin
-        key.update_columns(locked_at: nil, error_object: error) if error.present?
-      rescue => e
+        key.update_columns(locked_at: nil, error_object: rescued_error)
+      rescue StandardError => e
         # We're already inside an error condition, so swallow any additional
         # errors from here and just send them to logs.
         puts "Failed to unlock key #{key.id} because of #{e}."
@@ -148,8 +135,7 @@ module AcidicJob
                         :read_uncommitted
                       else
                         :serializable
-    end
-    serialized_job_info = serialize
+                      end
 
     ActiveRecord::Base.transaction(isolation: isolation_level) do
       @key = Key.find_by(idempotency_key: key_val)
@@ -157,11 +143,15 @@ module AcidicJob
       if @key
         # Programs enqueuing multiple jobs with different parameters but the
         # same idempotency key is a bug.
-        raise MismatchedIdempotencyKeyAndJobArguments if @key.job_args != serialized_job_info["arguments"]
+        if @key.job_args != @arguments_for_perform
+          raise MismatchedIdempotencyKeyAndJobArguments
+        end
 
         # Only acquire a lock if the key is unlocked or its lock has expired
         # because the original job was long enough ago.
-        raise LockedIdempotencyKey if @key.locked_at && @key.locked_at > Time.current - IDEMPOTENCY_KEY_LOCK_TIMEOUT
+        if @key.locked_at && @key.locked_at > Time.current - IDEMPOTENCY_KEY_LOCK_TIMEOUT
+          raise LockedIdempotencyKey
+        end
 
         # Lock the key and update latest run unless the job is already finished.
         @key.update!(last_run_at: Time.current, locked_at: Time.current) unless @key.finished?
@@ -171,8 +161,8 @@ module AcidicJob
           locked_at: Time.current,
           last_run_at: Time.current,
           recovery_point: first_step,
-          job_name: serialized_job_info["job_class"],
-          job_args: serialized_job_info["arguments"]
+          job_name: self.class.name,
+          job_args: @arguments_for_perform
         )
       end
     end
@@ -206,5 +196,13 @@ module AcidicJob
       end
     end
   end
+
+  def idempotency_key_value
+    return job_id if defined?(job_id) && !job_id.nil?
+    return jid if defined?(jid) && !jid.nil?
+
+    require 'securerandom'
+    SecureRandom.hex
+  end
 end
-# rubocop:enable Metrics/ModuleLength, Style/Documentation, Metrics/AbcSize, Metrics/MethodLength
+# rubocop:enable Metrics/ModuleLength, Metrics/AbcSize, Metrics/MethodLength

data/lib/generators/acidic_job_generator.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 require "rails/generators"
 require "rails/generators/active_record"
 
-# This generator adds a migration for the {FriendlyId::History
-# FriendlyId::History} addon.
 class AcidicJobGenerator < ActiveRecord::Generators::Base
-  # ActiveRecord::Generators::Base inherits from Rails::Generators::NamedBase which requires a NAME parameter for the
-  # new table name. Our generator always uses 'acidic_job_keys', so we just set a random name here.
+  # ActiveRecord::Generators::Base inherits from Rails::Generators::NamedBase
+  # which requires a NAME parameter for the new table name.
+  # Our generator always uses "acidic_job_keys", so we just set a random name here.
   argument :name, type: :string, default: "random_name"
 
   source_root File.expand_path("templates", __dir__)
@@ -21,9 +22,14 @@ class AcidicJobGenerator < ActiveRecord::Generators::Base
   end
 
   # Copies the migration template to db/migrate.
-  def copy_files
-    migration_template "migration.rb",
-      "db/migrate/create_acidic_job_keys.rb"
+  def copy_acidic_job_keys_migration_files
+    migration_template "create_acidic_job_keys_migration.rb.erb",
+                       "db/migrate/create_acidic_job_keys.rb"
+  end
+
+  def copy_staged_acidic_jobs_migration_files
+    migration_template "create_staged_acidic_jobs_migration.rb.erb",
+                       "db/migrate/create_staged_acidic_jobs.rb"
   end
 
   protected

data/lib/generators/templates/create_staged_acidic_jobs_migration.rb.erb

@@ -0,0 +1,9 @@
+class CreateStagedAcidicJobs < <%= migration_class %>
+  def change
+    create_table :staged_acidic_jobs do |t|
+      t.string :adapter, null: false
+      t.string :job_name, null: false
+      t.text :job_args, null: true
+    end
+  end
+end

data/slides.md

@@ -0,0 +1,65 @@
+# ACIDic Jobs
+
+## A bit about me
+
+- programming in Ruby for 6 years
+- working for test IO / EPAM
+- consulting for RCRDSHP
+- building Smokestack QA on the side
+
+## Jobs are essential
+
+- job / operation / work
+- in every company, with every app, jobs are essential. Why?
+- jobs are what your app *does*, expressed as a distinct unit
+- jobs can be called from anywhere, run sync or async, and have retry mechanisms built-in
+
+## Jobs are internal API endpoints
+
+- Like API endpoints, both are discrete units of work
+- Like API endpoints, we should expect failure
+- Like API endpoints, we should expect retries
+- Like API endpoints, we should expect concurrency
+- this symmetry allows us to port much of the wisdom built up over decades of building robust APIs to our app job infrastructure
+
+## ACIDic APIs
+
+In a loosely collected series of articles, Brandur Leach lays out the core techniques and principles required to make an HTTP API properly ACIDic:
+
+1. https://brandur.org/acid
+2. https://brandur.org/http-transactions
+3. https://brandur.org/job-drain
+4. https://brandur.org/idempotency-keys
+
+His central points can be summarized as follows:
+
+- "ACID databases are one of the most important tools in existence for ensuring maintainability and data correctness in big production systems"
+- "for a common idempotent HTTP request, requests should map to backend transactions at 1:1"
+- "We can dequeue jobs gracefully by using a transactionally-staged job drain."
+- "Implementations that need to make synchronous changes in foreign state (i.e. outside of a local ACID store) are somewhat more difficult to design. ... To guarantee idempotency on this type of endpoint we’ll need to introduce idempotency keys."
+
+Key concepts:
+
+- foreign state mutations
+  - The reason that the local vs. foreign distinction matters is that unlike a local set of operations where we can leverage an ACID store to roll back a result that we didn’t like, once we make our first foreign state mutation, we’re committed one way or another
+- "An atomic phase is a set of local state mutations that occur in transactions between foreign state mutations."
+- "A recovery point is a name of a check point that we get to after having successfully executed any atomic phase or foreign state mutation"
+- "transactionally-staged job drain"
+  - "With this pattern, jobs aren’t immediately sent to the job queue. Instead, they’re staged in a table within the relational database itself, and the ACID properties of the running transaction keep them invisible until they’re ready to be worked. A secondary enqueuer process reads the table and sends any jobs it finds to the job queue before removing their rows."
+
+
+https://github.com/mperham/sidekiq/wiki/Best-Practices#2-make-your-job-idempotent-and-transactional
+
+2. Make your job idempotent and transactional
+
+Idempotency means that your job can safely execute multiple times. For instance, with the error retry functionality, your job might be half-processed, throw an error, and then be re-executed over and over until it successfully completes. Let's say you have a job which voids a credit card transaction and emails the user to let them know the charge has been refunded:
+
+```ruby
+def perform(card_charge_id)
+  charge = CardCharge.find(card_charge_id)
+  charge.void_transaction
+  Emailer.charge_refunded(charge).deliver
+end
+```
+
+What happens when the email fails to render due to a bug? Will the void_transaction method handle the case where a charge has already been refunded? You can use a database transaction to ensure data changes are rolled back if there is an error or you can write your code to be resilient in the face of errors. Just remember that Sidekiq will execute your job at least once, not exactly once.

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: acidic_job
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.2
 platform: ruby
 authors:
 - fractaledmind
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-02 00:00:00.000000000 Z
+date: 2021-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -71,13 +71,21 @@ files:
 - acidic_job.gemspec
 - bin/console
 - bin/setup
+- blog_post.md
 - lib/acidic_job.rb
+- lib/acidic_job/errors.rb
+- lib/acidic_job/key.rb
 - lib/acidic_job/no_op.rb
+- lib/acidic_job/perform_transactionally_extension.rb
+- lib/acidic_job/perform_wrapper.rb
 - lib/acidic_job/recovery_point.rb
 - lib/acidic_job/response.rb
+- lib/acidic_job/staged.rb
 - lib/acidic_job/version.rb
 - lib/generators/acidic_job_generator.rb
-- lib/generators/templates/migration.rb
+- lib/generators/templates/create_acidic_job_keys_migration.rb.erb
+- lib/generators/templates/create_staged_acidic_jobs_migration.rb.erb
+- slides.md
 homepage: https://github.com/fractaledmind/acidic_job
 licenses:
 - MIT