acidic_job 1.0.0.pre2 → 1.0.0.pre5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c10032604b1b559edeb2426cd79e256d904ad15444d139f4f155eee1f01dd11
-  data.tar.gz: 4dafd1375706fd9a62cd5e0c20e576d2ab5c5ba0d10a1774182ce2dd8a62e615
+  metadata.gz: b8a9a11bcedbc8703e24c32db6474dfe963d8f97120c88c90dc4712026142d61
+  data.tar.gz: c558f6b90c1044c1320efc018fe4f9886f4af7ebab6a0c1fa8a991232e2b4065
 SHA512:
-  metadata.gz: fd0201a2a905e1c22af8873832bdab15ec08dc233561a978e5282077edb7aeaafd41257cd7be7bc4a64249b1fc41f382f2a1c97ade23e2eb5652a4b3a5687d17
-  data.tar.gz: 59930dbd34acf5cd52f1ec4b38173a945e2e64b0191c7d5786b863c732091bba44c2f918fd46746c138401b1e2c07228c9d68ff4c406978e431bf8745210fc14
+  metadata.gz: a9aef4b22eb6ee7860badda470c379d19395c60bc40072085ea3eae6ea140fd77103a07cf142a88310d90f67736300ceb3a755fe3f4283488caf36a7f872baf6
+  data.tar.gz: 8e1b7d428bc44f83274c3f64454d34c3467e7e701088aee862b71aec55c534a527d7d2e7e7a83fee4a94abe953284a092e8df24b55ae5c7fd195d8df968beb8f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    acidic_job (1.0.0.pre2)
+    acidic_job (1.0.0.pre5)
       activerecord (>= 6.1.0)
       activesupport
 

data/README.md

@@ -40,7 +40,7 @@ Or simply execute to install the gem yourself:
 Then, use the following command to copy over the `AcidicJob::Run` migration file.
 
 ```
-rails generate acidic_job
+rails generate acidic_job:install
 ```
 
 ## Usage

data/UPGRADE_GUIDE.md

@@ -0,0 +1,81 @@
+# AcidicJob Upgrade Guide
+
+1. Update version requirements in `Gemfile`
+
+```ruby
+-gem "acidic_job"
++gem "acidic_job", "~> 1.0.0.pre1"
+```
+
+result:
+```
+Installing acidic_job 1.0.0.pre4 (was 0.7.7)
+Bundle updated!
+```
+
+2. Generate migration for new `AcidicJob::Run` model
+
+```bash
+rails generate acidic_job
+```
+
+result:
+```
+create  db/migrate/#{yyyymmddhhmmss}_create_acidic_job_runs.rb
+```
+
+3. Delete any unneeded `AcidicJob::Key` records
+
+Typically, records that are already finished do not need to be retained. Sometimes, however, applications key finished records around for some amount of time for debugging or metrics aggregation. Whatever your application's logic is for whether or not an `AcidicJob::Key` record is still needed, for all unneeded records, delete them.
+
+For example, this would delete all finished `Key` records over 1 month old:
+
+```ruby
+AcidicJob::Key.where(recovery_point: AcidicJob::Key::RECOVERY_POINT_FINISHED, last_run_at: ..1.month.ago).delete_all
+```
+
+4. Migrate `AcidicJob::Key` to `AcidicJob::Run`
+
+`AcidicJob` ships with an upgrade module that provides a script to migrate older `Key` records to the new `Run` model.
+
+```ruby
+AcidicJob::UpgradeService.execute
+```
+
+This script will prepare an `insert_all` command for `Run` records by mapping the older `Key` data to the new `Run` schema. It also creates the new `Run` records with the same `id` as their `Key` counterparts, and then deletes all `Key` records successfully mapped over. Any `Key` records that were failed to be mapped over will be reported, along with the exception, in the `errored_keys` portion of the resulting hash.
+
+result:
+```
+{
+	run_records: <Integer>,
+	key_records: <Integer>,
+	errored_keys: <Array>
+}
+```
+
+5. Triage remaining `AcidicJob::Key` records
+
+If there were any `AcidicJob::Key` records that failed to be mapped to the new `Run` model, you will need to manually triage whatever the exception was. In all likelihood, the exception would be relating to the translation of the `Key#job_args` field to the `Run#serialized_job` field, as all other fields have a fairly straight-forward mapping. If you can't resolve the issue, please open an Issue in GitHub.
+
+6. Ensure all `AcidicJob::Staged` records are processed
+
+`AcidicJob` still ships with an upgrade module that provides the older `Key` and `Staged` records, so this functionality will still be present to handle any existing records in your database when you deploy the updated version.
+
+7. Remove the old tables
+
+Once you have successfully migrated everything over and the new system has been running smoothly for some time, you should drop the old `acidic_job_keys` and `staged_acidic_jobs` tables. We provide a migration generator just for this purpose:
+
+```bash
+rails generate acidic_job:drop_tables
+```
+
+result:
+```
+create  db/migrate/#{yyyymmddhhmmss}_drop_old_acidic_job_tables.rb
+```
+
+You can then run the migration to have those tables removed:
+
+```bash
+rails db:migrate
+```

data/lib/acidic_job/upgrade_service.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module AcidicJob
+  # recreate the original `Key` model
+  class Key < ::ActiveRecord::Base
+    RECOVERY_POINT_FINISHED = "FINISHED"
+
+    self.table_name = "acidic_job_keys"
+
+    serialize :error_object
+    serialize :job_args
+    serialize :workflow
+    store :attr_accessors
+  end
+
+  # recreate the original `Staged` model
+  class Staged < ActiveRecord::Base
+    self.table_name = "staged_acidic_jobs"
+
+    serialize :job_args
+
+    after_create_commit :enqueue_job
+
+    private
+
+    def enqueue_job
+      gid = { "staged_job_gid" => to_global_id.to_s }
+
+      if job_args.is_a?(Hash) && job_args.key?("arguments")
+        job_args["arguments"].concat([gid])
+      else
+        job_args.concat([gid])
+      end
+
+      case adapter
+      when "activejob"
+        ::ActiveJob::Base.deserialize(job_args).enqueue
+      when "sidekiq"
+        job_name.constantize.perform_async(*job_args)
+      else
+        raise UnknownJobAdapter.new(adapter: adapter)
+      end
+
+      # NOTE: record will be deleted after the job has successfully been performed
+      true
+    end
+  end
+
+  module UpgradeService
+    def self.execute
+      # prepare an array to hold the attribute hashes to be passed to `insert_all`
+      run_attributes = []
+      # prepare an array to hold any `Key` records that we couldn't successfully map to `Run` records
+      errored_keys = []
+
+      # iterate over all `AcidicJob::Key` records in batches,
+      # preparing a `Run` attribute hash to be passed to `insert_all`
+      ::AcidicJob::Key.find_each do |key|
+        # map all of the simple attributes directly
+        attributes = {
+          id: key.id,
+          staged: false,
+          idempotency_key: key.idempotency_key,
+          job_class: key.job_name,
+          last_run_at: key.last_run_at,
+          locked_at: key.locked_at,
+          recovery_point: key.recovery_point,
+          error_object: key.error_object,
+          attr_accessors: key.attr_accessors,
+          workflow: key.workflow,
+          created_at: key.created_at,
+          updated_at: key.updated_at
+        }
+
+        # prepare the more complicated `job_args` -> `serialized_job` translation
+        job_class = key.job_name.constantize
+        if defined?(::Sidekiq) && job_class.include?(::Sidekiq::Worker)
+          unless job_class.include?(::AcidicJob::Extensions::Sidekiq)
+            job_class.include(::AcidicJob::Extensions::Sidekiq)
+          end
+          job_instance = job_class.new
+          serialized_job = job_instance.serialize_job(*key.job_args)
+        elsif defined?(::ActiveJob) && job_class < ::ActiveJob::Base
+          unless job_class.include?(::AcidicJob::Extensions::ActiveJob)
+            job_class.include(::AcidicJob::Extensions::ActiveJob)
+          end
+          job_args = begin
+            ::ActiveJob::Arguments.deserialize(key.job_args)
+          rescue ::ActiveJob::DeserializationError
+            key.job_args
+          end
+          job_instance = job_class.new(*job_args)
+          serialized_job = job_instance.serialize_job
+        end
+
+        attributes[:serialized_job] = serialized_job
+        run_attributes << attributes
+      rescue StandardError => e
+        errored_keys << [e, key]
+      end
+
+      # insert all of the `Run` records
+      ::AcidicJob::Run.insert_all(run_attributes)
+
+      # delete all successfully migrated `Key` record
+      ::AcidicJob::Key.where(id: ::AcidicJob::Run.select(:id)).delete_all
+
+      # return a report of the upgrade migration
+      {
+        run_records: ::AcidicJob::Run.count,
+        key_records: ::AcidicJob::Key.count,
+        errored_keys: errored_keys
+      }
+    end
+  end
+end

data/lib/acidic_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AcidicJob
-  VERSION = "1.0.0.pre2"
+  VERSION = "1.0.0.pre5"
 end

data/lib/acidic_job.rb

@@ -14,6 +14,7 @@ require_relative "acidic_job/extensions/sidekiq"
 require_relative "acidic_job/extensions/action_mailer"
 require_relative "acidic_job/extensions/active_job"
 require_relative "acidic_job/extensions/noticed"
+require_relative "acidic_job/upgrade_service"
 
 require "active_support/concern"
 

data/lib/generators/acidic_job/drop_tables_generator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module AcidicJob
+  module Generators
+    class DropTablesGenerator < ::Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Drops the pre-1.0 tables for the AcidicJob::Key and AcidicJob::Staged models."
+
+      def copy_migration
+        migration_template "drop_acidic_job_keys_migration.rb.erb",
+                           "db/migrate/drop_old_acidic_job_tables.rb",
+                           migration_version: migration_version
+      end
+
+      protected
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/acidic_job/install_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module AcidicJob
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Generates a migration for the AcidicJob::Run table."
+
+      # Copies the migration template to db/migrate.
+      def copy_acidic_job_runs_migration_files
+        migration_template "create_acidic_job_runs_migration.rb.erb",
+                           "db/migrate/create_acidic_job_runs.rb",
+                           migration_version: migration_version
+      end
+
+      protected
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/{templates → acidic_job/templates}/create_acidic_job_runs_migration.rb.erb

@@ -1,4 +1,4 @@
-class CreateAcidicJobRuns < <%= migration_class %>
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
   def change
     create_table :acidic_job_runs do |t|
       t.boolean 	:staged, 					null: false, 	default: -> { false }

data/lib/generators/acidic_job/templates/drop_acidic_job_keys_migration.rb.erb

@@ -0,0 +1,27 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    drop_table :acidic_job_keys do |t|
+      t.string :idempotency_key, null: false
+      t.string :job_name, null: false
+      t.text :job_args, null: true
+      t.datetime :last_run_at, null: false, default: -> { "CURRENT_TIMESTAMP" }
+      t.datetime :locked_at, null: true
+      t.string :recovery_point, null: false
+      t.text :error_object
+      t.text :attr_accessors
+      t.text :workflow
+      t.timestamps
+    
+      t.index %i[idempotency_key job_name job_args],
+        unique: true,
+        name: "idx_acidic_job_keys_on_idempotency_key_n_job_name_n_job_args"
+    end
+    
+    drop_table :staged_acidic_jobs do |t|
+      t.string :adapter, null: false
+      t.string :job_name, null: false
+      t.text :job_args, null: true
+      t.timestamps
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acidic_job
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre2
+  version: 1.0.0.pre5
 platform: ruby
 authors:
 - fractaledmind
@@ -68,6 +68,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- UPGRADE_GUIDE.md
 - acidic_job.gemspec
 - bin/console
 - bin/setup
@@ -86,9 +87,12 @@ files:
 - lib/acidic_job/run.rb
 - lib/acidic_job/staging.rb
 - lib/acidic_job/step.rb
+- lib/acidic_job/upgrade_service.rb
 - lib/acidic_job/version.rb
-- lib/generators/acidic_job_generator.rb
-- lib/generators/templates/create_acidic_job_runs_migration.rb.erb
+- lib/generators/acidic_job/drop_tables_generator.rb
+- lib/generators/acidic_job/install_generator.rb
+- lib/generators/acidic_job/templates/create_acidic_job_runs_migration.rb.erb
+- lib/generators/acidic_job/templates/drop_acidic_job_keys_migration.rb.erb
 homepage: https://github.com/fractaledmind/acidic_job
 licenses:
 - MIT

data/lib/generators/acidic_job_generator.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-require "rails/generators/active_record"
-
-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_runs", so we just set a random name here.
-  argument :name, type: :string, default: "random_name"
-
-  source_root File.expand_path("templates", __dir__)
-
-  def self.next_migration_number(_path)
-    if instance_variable_defined?("@prev_migration_nr") # :nocov:
-      @prev_migration_nr += 1
-    else
-      @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
-    end
-
-    @prev_migration_nr.to_s
-  end
-
-  # Copies the migration template to db/migrate.
-  def copy_acidic_job_runs_migration_files
-    migration_template "create_acidic_job_runs_migration.rb.erb",
-                       "db/migrate/create_acidic_job_runs.rb"
-  end
-
-  protected
-
-  def migration_class
-    ActiveRecord::Migration["#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"]
-  end
-end