acidic_job 1.0.0.pre26 → 1.0.0.pre29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12ef46783f7518f53f6f92384087761abecfa81576e72c6c9f8facdec94182a3
-  data.tar.gz: c39ab11338a29020c6700d7cb9707b0ac9a28a7971f9125247cfbb35eee06b21
+  metadata.gz: 41d83dcc9ad4d8b835881a8268e43c8d74f7ae87e8e6dd0ad07e79f8f0df1319
+  data.tar.gz: 651b7eb29e6f2c3ec006b18151ae80ca5efeaf17093495656dde87420774c8ac
 SHA512:
-  metadata.gz: 4560e80dbfcac6f59efee5cae6236e430cae66ef54928e0f8258180752fdbc78161b421e39d9df46cdc67a528b170589d08db78a609ad52d263cae3b63387c8d
-  data.tar.gz: 8c23139c2f27dda273bb504a13d45afcf60e5ffec1ad9351cbf984da0ffb2de399cc693f0f98d1edbb053f1b62e2d0a46ba9bac6baa3c43a9d8dd2458cb79eb5
+  metadata.gz: 66289b30eae68ad0742f4f744ee509ddaeba4a9cb769101ca836482e8820c64755b63dd1030da3ea152bae73151121af821cfdb0d6f9f26ed80453ca1e2f1f0f
+  data.tar.gz: c1c2522cf165f8a3f693aa9ac5839b3e2f1df9f057fe2f7776f1e42c9eb718847f4b3f81e86ca5230b4532dc909505920671f9539f0ca1f20a5c65f196a86c75

data/.gitignore

@@ -12,3 +12,5 @@ slides.md
 /test/dummy
 /test/log
 /database.sqlite
+/test/combustion/log/test.log
+/test/combustion/database.sqlite

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    acidic_job (1.0.0.pre26)
+    acidic_job (1.0.0.pre29)
       activerecord
       activesupport
       database_cleaner
@@ -144,6 +144,8 @@ GEM
     nokogiri (1.13.7)
       mini_portile2 (~> 2.8.0)
       racc (~> 1.4)
+    nokogiri (1.13.7-x86_64-darwin)
+      racc (~> 1.4)
     noticed (1.5.9)
       http (>= 4.0.0)
       rails (>= 5.2.0)

data/README.md

@@ -246,7 +246,7 @@ class RideCreateJob < ActiveJob::Base
 end
 ```
 
-**Note:** This does mean that you are restricted to objects that can be serialized by ActiveRecord, thus no Procs, for example.
+**Note:** This does mean that you are restricted to objects that can be serialized by **`ActiveJob`** (for more info, see [here](https://edgeguides.rubyonrails.org/active_job_basics.html#supported-types-for-arguments)). This means you can persist ActiveRecord models, and any simple Ruby data types, but you can't persist things like Procs or custom class instances, for example.
 
 **Note:** You will note the use of `self.ride = ...` in the code sample above. In order to call the attribute setter method that will sync with the database record, you _must_ use this style. `@ride = ...` and/or `ride = ...` will both fail to sync the value with the database record.
 

data/lib/acidic_job/awaiting.rb

@@ -27,6 +27,10 @@ module AcidicJob
       # which is what the `after_finish :reenqueue_awaited_by_job` check needs
       job.instance_variable_set(:@acidic_job_run, run)
 
+      # can't reproduce yet, but saw a bug in production where
+      # nested awaits workflows had an unsaved `workflow` attribute
+      run.save! if run.has_changes_to_save?
+
       step = Step.new(current_step, run, job, step_result)
       # TODO: WRITE REGRESSION TESTS FOR PARALLEL JOB FAILING AND RETRYING THE ORIGINAL STEP
       step.progress

data/lib/acidic_job/extensions/sidekiq.rb

@@ -47,7 +47,7 @@ module AcidicJob
           arguments = args || @args
           arguments += [kwargs] unless kwargs.empty?
           normalized_args = ::Sidekiq.load_json(::Sidekiq.dump_json(arguments))
-          item = { "class" => self.class, "args" => normalized_args, "jid" => jid }
+          item = { "class" => self.class.name, "args" => normalized_args, "jid" => jid }
           sidekiq_options = sidekiq_options_hash || {}
 
           sidekiq_options.merge(item)

data/lib/acidic_job/run.rb

@@ -3,6 +3,7 @@
 require "active_record"
 require "global_id"
 require "active_support/core_ext/object/with_options"
+require_relative "./serializer"
 
 module AcidicJob
   class Run < ActiveRecord::Base
@@ -17,11 +18,11 @@ module AcidicJob
 
     after_create_commit :enqueue_staged_job, if: :staged?
 
-    serialize :error_object
-    serialize :serialized_job
-    serialize :workflow
-    serialize :returning_to
-    store :attr_accessors
+    serialize :serialized_job, JSON
+    serialize :error_object, Serializer
+    serialize :workflow, Serializer
+    serialize :returning_to, Serializer
+    store :attr_accessors, coder: Serializer
 
     validates :staged, inclusion: { in: [true, false] } # uses database default
     validates :serialized_job, presence: true

data/lib/acidic_job/serializer.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "active_job/serializers"
+require "active_job/arguments"
+require "json"
+
+class WorkerSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize(worker)
+    super(
+      "class" => worker.class.name,
+      "args" => worker.instance_variable_get(:@__acidic_job_args),
+      "kwargs" => worker.instance_variable_get(:@__acidic_job_kwargs)
+    )
+  end
+
+  def deserialize(hash)
+    worker_class = hash["class"].constantize
+    worker_class.new(*hash["args"], **hash["kwargs"])
+  end
+
+  def serialize?(argument)
+    defined?(::Sidekiq) && argument.class.include?(::Sidekiq::Worker)
+  end
+end
+
+class JobSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize(job)
+    super(job.serialize)
+  end
+
+  def deserialize(hash)
+    job = ActiveJob::Base.deserialize(hash)
+    job.send(:deserialize_arguments_if_needed)
+    if job.arguments.last.is_a?(Hash)
+      *args, kwargs = job.arguments
+    else
+      args = job.arguments
+      kwargs = {}
+    end
+    job.instance_variable_set(:@__acidic_job_args, args)
+    job.instance_variable_set(:@__acidic_job_kwargs, kwargs)
+
+    job
+  end
+
+  def serialize?(argument)
+    defined?(::ActiveJob::Base) && argument.class < ::ActiveJob::Base
+  end
+end
+
+class ExceptionSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize(exception)
+    hash = {
+      "class" => exception.class.name,
+      "message" => exception.message,
+      "cause" => exception.cause,
+      "backtrace" => {}
+    }
+
+    exception.backtrace.map do |trace|
+      path, _, location = trace.rpartition("/")
+
+      next if hash["backtrace"].key?(path)
+
+      hash["backtrace"][path] = location
+    end
+
+    super(hash)
+  end
+
+  def deserialize(hash)
+    exception_class = hash["class"].constantize
+    exception = exception_class.new(hash["message"])
+    exception.set_backtrace(hash["backtrace"].map do |path, location|
+      [path, location].join("/")
+    end)
+    exception
+  end
+
+  def serialize?(argument)
+    defined?(Exception) && argument.is_a?(Exception)
+  end
+end
+
+class FinishedPointSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize(finished_point)
+    super(
+      "class" => finished_point.class.name
+    )
+  end
+
+  def deserialize(hash)
+    finished_point_class = hash["class"].constantize
+    finished_point_class.new
+  end
+
+  def serialize?(argument)
+    defined?(::AcidicJob::FinishedPoint) && argument.is_a?(::AcidicJob::FinishedPoint)
+  end
+end
+
+class RecoveryPointSerializer < ActiveJob::Serializers::ObjectSerializer
+  def serialize(recovery_point)
+    super(
+      "class" => recovery_point.class.name,
+      "name" => recovery_point.name
+    )
+  end
+
+  def deserialize(hash)
+    recovery_point_class = hash["class"].constantize
+    recovery_point_class.new(hash["name"])
+  end
+
+  def serialize?(argument)
+    defined?(::AcidicJob::RecoveryPoint) && argument.is_a?(::AcidicJob::RecoveryPoint)
+  end
+end
+
+ActiveJob::Serializers.add_serializers(
+  WorkerSerializer,
+  JobSerializer,
+  ExceptionSerializer,
+  FinishedPointSerializer,
+  RecoveryPointSerializer
+)
+
+# ...
+module AcidicJob
+  module Arguments
+    include ActiveJob::Arguments
+    extend self # rubocop:disable Style/ModuleFunction
+
+    # `ActiveJob` will throw an error if it tries to deserialize a GlobalID record.
+    # However, this isn't the behavior that we want for our custom `ActiveRecord` serializer.
+    # Since `ActiveRecord` does _not_ reset instance record state to its pre-transactional state
+    # on a transaction ROLLBACK, we can have GlobalID entries in a serialized column that point to
+    # non-persisted records. This is ok. We should simply return `nil` for that portion of the
+    # serialized field.
+    def deserialize_global_id(hash)
+      GlobalID::Locator.locate hash[GLOBALID_KEY]
+    rescue ActiveRecord::RecordNotFound
+      nil
+    end
+  end
+
+  class Serializer
+    # Used for `serialize` method in ActiveRecord
+    class << self
+      def load(json)
+        return if json.nil? || json.empty?
+
+        data = JSON.parse(json)
+        Arguments.deserialize(data).first
+      end
+
+      def dump(obj)
+        data = Arguments.serialize [obj]
+        data.to_json
+      end
+    end
+  end
+end

data/lib/acidic_job/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: acidic_job
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre26
+  version: 1.0.0.pre29
 platform: ruby
 authors:
 - fractaledmind
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-20 00:00:00.000000000 Z
+date: 2022-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -300,6 +300,7 @@ files:
 - lib/acidic_job/recovery_point.rb
 - lib/acidic_job/rspec_configuration.rb
 - lib/acidic_job/run.rb
+- lib/acidic_job/serializer.rb
 - lib/acidic_job/staging.rb
 - lib/acidic_job/step.rb
 - lib/acidic_job/test_case.rb