activerecord-transactionable 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c72bcd7d394827cc75722f18b5c963b202553a16a5bce5be6163a68f43e9706a
-  data.tar.gz: e55157daee5fba12b52c21db6296895bc794385ad6ee64ce5b10a5ad3c7ca036
+  metadata.gz: 40e310ce0f07066a58c6b6a813b79c8f5dcfda4c63775e0eba78becbea0f156a
+  data.tar.gz: 0d583ee211e147bb1d14c514bdb3497091433fa00733fdefcfc4571446425e5b
 SHA512:
-  metadata.gz: ce66e65e7cc433cb3c1ce7137a718a295356ebc21b04a827288f040d4075d145af80ef0d272e7eee0638a69afd761d58ae12e8a7e93cd23c710e8313130e8c14
-  data.tar.gz: 2760e001a9905e5ce35e0c229e28df5a01d013bf23aa93ada9ca674c3ec01a3b993659113e5399a3f8f84c43119dfc419d71db26952f4e16cfce1cbfff184686
+  metadata.gz: 428e31d3bee1d6c842d27b6a17d6143d1ad00c781e9663e4ea6ff9da5e4b8f1f584d2147f2f3c69330de1e31defdd2722a2015e0dc8f4a11718b6ba4cce4cefd
+  data.tar.gz: e14d70b5d072b34303cce8f38f7ddacc13282bd6f0d45e05baa6789d1f81c248fbd170010943d2a09d03c9047fc361d72652304c2af0fdf4a208ed509eaa7a0d

data/README.md

@@ -134,18 +134,19 @@ transaction_result =  @client.transaction_wrapper(lock: true) do
 if transaction_result.success?
   render :show, locals: { client: @client }, status: :ok
 else
-  # Something prevented update
-  render json: @client.errors, status: :unprocessable_entity
+  # Something prevented update, transaction_result.to_h will have all the available details
+  render json: { record_errors: @client.errors, transaction_result: transaction_result.to_h }, status: :unprocessable_entity
 end
 ```
 
 ## Find or create
 
-NOTE: The `is_retry` is passed to the block by the gem, and indicates whether the block is running for the first time or the second time.
+NOTE: The `is_retry` is passed to the block by the gem, and indicates whether the block is running for the first time or the second, or nth, time.
 The block will never be retried more than once.
 
 ```ruby
-Car.transaction_wrapper(outside_retriable_errors: ActivRecord::RecordNotFound) do |is_retry|
+Car.transaction_wrapper(outside_retriable_errors: ActivRecord::RecordNotFound, outside_num_retry_attempts: 3) do |is_retry|
+  # is_retry will be falsey on first attempt, thereafter will be the integer number of the attempt
   if is_retry
     Car.create!(vin: vin)
   else
@@ -161,6 +162,7 @@ The block will never be retried more than once.
 
 ```ruby
 Car.transaction_wrapper(outside_retriable_errors: ActivRecord::RecordNotUnique) do |is_retry|
+  # is_retry will be falsey on first attempt, thereafter will be the integer number of the attempt
   if is_retry
     Car.find_by!(vin: vin)
   else

data/lib/activerecord/transactionable.rb

@@ -15,6 +15,7 @@ module Activerecord # Note lowercase "r" in Activerecord (different namespace th
   module Transactionable
     extend ActiveSupport::Concern
 
+    DEFAULT_NUM_RETRY_ATTEMPTS = 2
     DEFAULT_ERRORS_TO_HANDLE_INSIDE_TRANSACTION = [].freeze
     DEFAULT_ERRORS_PREPARE_ON_SELF_INSIDE = [].freeze
     DEFAULT_ERRORS_TO_HANDLE_OUTSIDE_TRANSACTION = [ActiveRecord::RecordInvalid].freeze
@@ -38,12 +39,14 @@ module Activerecord # Note lowercase "r" in Activerecord (different namespace th
       prepared_errors
       retriable_errors
       reraisable_errors
+      num_retry_attempts
     ].freeze
     OUTSIDE_TRANSACTION_ERROR_HANDLERS = %i[
       outside_rescued_errors
       outside_prepared_errors
       outside_retriable_errors
       outside_reraisable_errors
+      outside_num_retry_attempts
     ].freeze
     INSIDE_CONTEXT = 'inside'.freeze
     OUTSIDE_CONTEXT = 'outside'.freeze
@@ -124,11 +127,12 @@ module Activerecord # Note lowercase "r" in Activerecord (different namespace th
         prepared_errors = Array(args[:prepared_errors])
         retriable_errors = Array(args[:retriable_errors])
         reraisable_errors = Array(args[:reraisable_errors])
+        num_retry_attempts = args[:num_retry_attempts] ? args[:num_retry_attempts].to_i : DEFAULT_NUM_RETRY_ATTEMPTS
         rescued_errors.concat(DEFAULT_ERRORS_TO_HANDLE_INSIDE_TRANSACTION)
         prepared_errors.concat(DEFAULT_ERRORS_PREPARE_ON_SELF_INSIDE)
         already_been_added_to_self, needing_added_to_self = rescued_errors.partition { |error_class| prepared_errors.include?(error_class) }
         local_context = INSIDE_CONTEXT
-        run_block_with_retry(object, local_context, transaction_open, retriable_errors, reraisable_errors, already_been_added_to_self, needing_added_to_self) do |is_retry|
+        run_block_with_retry(object, local_context, transaction_open, retriable_errors, reraisable_errors, already_been_added_to_self, needing_added_to_self, num_retry_attempts) do |is_retry|
           yield is_retry
         end
       end
@@ -138,19 +142,22 @@ module Activerecord # Note lowercase "r" in Activerecord (different namespace th
         prepared_errors = Array(args[:outside_prepared_errors])
         retriable_errors = Array(args[:outside_retriable_errors])
         reraisable_errors = Array(args[:outside_reraisable_errors])
+        num_retry_attempts = args[:outside_num_retry_attempts] ? args[:outside_num_retry_attempts].to_i : DEFAULT_NUM_RETRY_ATTEMPTS
         rescued_errors.concat(DEFAULT_ERRORS_TO_HANDLE_OUTSIDE_TRANSACTION)
         prepared_errors.concat(DEFAULT_ERRORS_PREPARE_ON_SELF_OUTSIDE)
         already_been_added_to_self, needing_added_to_self = rescued_errors.partition { |error_class| prepared_errors.include?(error_class) }
         local_context = OUTSIDE_CONTEXT
-        run_block_with_retry(object, local_context, transaction_open, retriable_errors, reraisable_errors, already_been_added_to_self, needing_added_to_self) do |is_retry|
+        run_block_with_retry(object, local_context, transaction_open, retriable_errors, reraisable_errors, already_been_added_to_self, needing_added_to_self, num_retry_attempts) do |is_retry|
           yield is_retry
         end
       end
 
-      def run_block_with_retry(object, local_context, transaction_open, retriable_errors, reraisable_errors, already_been_added_to_self, needing_added_to_self)
+      def run_block_with_retry(object, local_context, transaction_open, retriable_errors, reraisable_errors, already_been_added_to_self, needing_added_to_self, num_retry_attempts)
+        attempt = 0
         re_try = false
         begin
-          # If the block we yield to here raises an error that is not caught below the `true` will not get hit.
+          attempt += 1
+          # If the block we yield to here raises an error that is not caught below the `re_try = true` will not get hit.
           # If the error is rescued higher up, like where the transaction in active record
           #   rescues ActiveRecord::Rollback without re-raising, then transaction_wrapper will return nil
           # If the error is not rescued higher up the error will continue to bubble
@@ -159,54 +166,57 @@ module Activerecord # Note lowercase "r" in Activerecord (different namespace th
           # We pass the retry state along to yield so that the code implementing
           #   the transaction_wrapper can switch behavior on a retry
           #   (e.g. create => find)
-          result = yield re_try
+          result = yield (re_try == false ? re_try : attempt)
           # When in the outside context we need to preserve the inside result so it bubbles up unmolested with the "meaningful" result of the transaction.
           if result.is_a?(Activerecord::Transactionable::Result)
             result # <= preserve the meaningful return value
           else
-            Activerecord::Transactionable::Result.new(true, context: local_context, transaction_open: transaction_open) # <= make the return value meaningful.  Meaning: transaction succeeded, no errors raised
+            Activerecord::Transactionable::Result.new(true, context: local_context, attempt: attempt, transaction_open: transaction_open) # <= make the return value meaningful.  Meaning: transaction succeeded, no errors raised
           end
         rescue *reraisable_errors => error
           # This has highest precedence because raising is the most critical functionality of a raised error to keep
           #   if that is in the intended behavior, and this way a specific child of StandardError can be reraised while
           #   the parent can still be caught and added to self.errors
           # Also adds the error to the object if there is an object.
-          transaction_error_logger(object: object, error: error, add_to: nil, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context} re-raising!]")
+          transaction_error_logger(object: object, error: error, result: nil, attempt: attempt, add_to: nil, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context} re-raising!]")
           raise error
         rescue *retriable_errors => error
           # This will re-run the begin block above
           # WARNING: If the same error keeps getting thrown this would infinitely recurse!
           #          To avoid the infinite recursion, we track the retry state
-          if re_try
-            transaction_error_logger(object: object, error: error, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context} 2nd attempt]")
-            Activerecord::Transactionable::Result.new(false, context: local_context, transaction_open: transaction_open, error: error, type: 'retriable') # <= make the return value meaningful.  Meaning is: transaction failed after two attempts
+          if attempt >= num_retry_attempts
+            result = Activerecord::Transactionable::Result.new(false, context: local_context, transaction_open: transaction_open, error: error, attempt: attempt, type: 'retriable') # <= make the return value meaningful.  Meaning is: transaction failed after <attempt> attempts
+            transaction_error_logger(object: object, error: error, result: result, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context}]")
+            result
           else
             re_try = true
             # Not adding error to base when retrying, because otherwise the added error may
             #   prevent the subsequent save from working, in a catch-22
-            transaction_error_logger(object: object, error: error, add_to: nil, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context} 1st attempt]")
+            transaction_error_logger(object: object, error: error, result: nil, attempt: attempt, add_to: nil, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context}]")
             retry
           end
         rescue *already_been_added_to_self => error
           # ActiveRecord::RecordInvalid, when done correctly, will have already added the error to object.
-          transaction_error_logger(object: nil, error: error, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context}]")
-          Activerecord::Transactionable::Result.new(false, context: local_context, transaction_open: transaction_open, error: error, type: 'already_added') # <= make the return value meaningful.  Meaning is: transaction failed
+          result = Activerecord::Transactionable::Result.new(false, context: local_context, transaction_open: transaction_open, error: error, attempt: attempt, type: 'already_added') # <= make the return value meaningful.  Meaning is: transaction failed
+          transaction_error_logger(object: nil, error: error, result: result, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context}]")
+          result
         rescue *needing_added_to_self => error
-          transaction_error_logger(object: object, error: error, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context}]")
-          Activerecord::Transactionable::Result.new(false, context: local_context, transaction_open: transaction_open, error: error, type: 'needing_added') # <= make the return value meaningful.  Meaning is: transaction failed
+          result = Activerecord::Transactionable::Result.new(false, context: local_context, transaction_open: transaction_open, error: error, attempt: attempt, type: 'needing_added') # <= make the return value meaningful.  Meaning is: transaction failed
+          transaction_error_logger(object: object, error: error, result: result, additional_message: " [#{transaction_open ? 'nested ' : ''}#{local_context}]")
+          result
         end
       end
 
-      def transaction_error_logger(object:, error:, add_to: :base, additional_message: nil)
+      def transaction_error_logger(object:, error:, result:, attempt: nil, add_to: :base, additional_message: nil, **opts)
         # Ruby arguments, like object, are passed by reference,
         #   so this update to errors will be available to the caller
         if object.nil?
           # when a transaction wraps a bunch of CRUD actions,
           #   the specific record that caused the ActiveRecord::RecordInvalid error may be out of scope
           # Ideally you would rewrite the caller to call transaction_wrapper on a single record (even if updates happen on other records)
-          logger.error("[#{self}.transaction_wrapper] #{error.class}: #{error.message}#{additional_message}")
+          logger.error("[#{self}.transaction_wrapper] #{error.class}: #{error.message}#{additional_message}[#{attempt || (result && result.to_h[:attempt])}]")
         else
-          logger.error("[#{self}.transaction_wrapper] On #{object.class} #{error.class}: #{error.message}#{additional_message}")
+          logger.error("[#{self}.transaction_wrapper] On #{object.class} #{error.class}: #{error.message}#{additional_message}[#{attempt || (result && result.to_h[:attempt])}]")
           object.errors.add(add_to, error.message) unless add_to.nil?
         end
       end

data/lib/activerecord/transactionable/result.rb

@@ -1,12 +1,13 @@
 module Activerecord
   module Transactionable
     class Result
-      attr_reader :value, :result, :error, :type, :context, :nested
-      def initialize(value, context:, transaction_open:, error: nil, type: nil)
+      attr_reader :value, :result, :error, :type, :context, :nested, :attempt
+      def initialize(value, context:, transaction_open:, attempt:, error: nil, type: nil)
         @value = value
         @result = fail? ? 'fail' : 'success'
         @context = context
         @nested = transaction_open ? true : false
+        @attempt = attempt
         @error = error
         @type = type
       end
@@ -19,22 +20,23 @@ module Activerecord
         value == true
       end
 
-      def to_h
+      def to_h(skip_error: nil)
         diagnostic_data = {
             result: result,
             type: type,
             context: context,
-            nested: nested
+            nested: nested,
+            attempt: attempt,
         }
         diagnostic_data.merge!(
           error: error.class.to_s,
           message: error.message,
-        ) if error
+        ) if !skip_error && error
         diagnostic_data
       end
 
-      def to_s
-        to_h.to_s
+      def to_s(skip_error: nil)
+        to_h(skip_error: skip_error).to_s
       end
     end
   end

data/lib/activerecord/transactionable/version.rb

@@ -1,5 +1,5 @@
 module Activerecord
   module Transactionable
-    VERSION = '2.0.3'.freeze
+    VERSION = '2.0.4'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-transactionable
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Peter Boling
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-12 00:00:00.000000000 Z
+date: 2018-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel