axn 0.1.0.pre.alpha.2.6 → 0.1.0.pre.alpha.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49a6ab763d534efa878ff7f0d833beefeaae604bddb1c2e89090788a1e7df1a0
-  data.tar.gz: 828cfbd5ad2b9f753bf938bdb84201edbb406b367c159d4b1f437054a3bc213f
+  metadata.gz: b128603df1eec45048f8656f01508a2e9a706e9acd92ce74813cac0bb038f550
+  data.tar.gz: cfc86ffaadab4cc758546eab39992de2d7f3c89547007a2d88643b303d0edd4b
 SHA512:
-  metadata.gz: 8be59eb695a3df836513fb477b2338bb539da209821d17ab6502314ea57e62204e9a0e5ae49ec579db5d5c8e99ca6de57596acf577ee2027d8410e23a5013f15
-  data.tar.gz: 1a559aff5de117890928f67a5e0adefe1f2615c24f15ac6357dff0c74bd3f9a9470110618228a30aaba35ae489844cca4efd1f701aba0f1805c18b5c71edd7a9
+  metadata.gz: 2767343c37a0612a446482b52320d2ab85009af9e4094fffa0be31577bdf4a67e228f08307e31c0d182dbd3b944881f10af3c7e80d19a7d6c6f6f08a33294417
+  data.tar.gz: fb5d3942ecbeb2e52f4f4376b5d1b90db696470704d39d1b2db55e6880956073f12f0213a13ad8a564ee2048ad76350bebb811ff90db125bf9724d2d31d3167a

data/.rubocop.yml

@@ -42,8 +42,11 @@ Metrics/BlockLength:
 Metrics/ModuleLength:
   Enabled: false
 
+Metrics/ClassLength:
+  Max: 110
+
 Metrics/MethodLength:
-  Max: 60
+  Max: 70
 
 Metrics/PerceivedComplexity:
   Max: 16

data/CHANGELOG.md

@@ -1,7 +1,28 @@
 # Changelog
 
-## Unreleased
-* N/A
+## 0.1.0-alpha.2.7
+* [BREAKING] Replaced `messages` declaration with separate `success` and `error` calls
+* [BREAKING] Removed `rescues` method (use `error_from` for custom error messages; all exceptions now report to `on_exception` handlers)
+* [BREAKING] Replaced `error_from` with an optional `if:` argument on `error`
+  * [FEAT] Implemented conditional success message filtering as well
+* [FEAT] Added block support for `error` and `success`
+* [FEAT] `if:` now supports symbol predicates referencing instance methods (arity 0, 1, or keyword `exception:`). If the method accepts `exception:` it is passed as a keyword; else if it accepts one positional arg, it is passed positionally; otherwise it is called with no args. If the method is missing, the symbol falls back to constant lookup (e.g., `:ArgumentError`).
+* [FEAT] `success`/`error` and callbacks now accept symbol method names (e.g., `success :local_method`). Handlers can receive the exception via keyword (`exception:`) or single positional argument; otherwise they are called with no args.
+* [BREAKING] Updated callback methods (`on_success`, `on_error`, `on_failure`, `on_exception`) to use consistent `if:` interface (matching messages)
+* [FEAT] Added `unless:` support to both `success`/`error` messages and callbacks (`on_success`, `on_error`, `on_failure`, `on_exception`)
+
+## 0.1.0-alpha.2.6.1
+* [FEAT] Added `elapsed_time` and `outcome` methods to `Action::Result`
+  * `elapsed_time` returns execution time in milliseconds (Float)
+  * `outcome` returns execution outcome as symbol (`:success`, `:failure`, or `:exception`)
+* [BREAKING] `emit_metrics` hook now receives the full `Action::Result` object instead of just the outcome
+  * Provides access to both outcome and elapsed time for richer metrics
+  * Example: `proc { |resource, result| TS::Metrics.histogram("action.duration", result.elapsed_time) }`
+* [BREAKING] Replaced `Action.config.default_log_level` and `default_autolog_level` with simpler `log_level`
+* [BREAKING] `autolog_level` method overrides with e.g. `auto_log :warn` or `auto_log false`
+* [BREAKING] Direct access to exposed fields in callables no longer works -- `foo` becomes `result.foo`
+* [BREAKING] Removed `success?` check on Action::Result (use `ok?` instead)
+* [FEAT] Added callback and strategy support to Axn::Factory.build
 
 ## 0.1.0-alpha.2.6
 * Inline interactor code (no more dependency on unpublished forked branch to support inheritance)

data/docs/reference/action-result.md

@@ -9,6 +9,8 @@ Every `call` invocation on an Action will return an `Action::Result` instance, w
 | `success` | User-facing success message (string), if `ok?` (else nil)
 | `message` | User-facing message (string), always defined (`ok? ? success : error`)
 | `exception` | If not `ok?` because an exception was swallowed, will be set to the swallowed exception (note: rarely used outside development; prefer to let the library automatically handle exception handling for you)
+| `outcome` | The execution outcome as a symbol (`:success`, `:failure`, or `:exception`)
+| `elapsed_time` | Execution time in milliseconds (Float)
 | any `expose`d values | guaranteed to be set if `ok?` (since they have outgoing presence validations by default; any missing would have failed the action)
 
 NOTE: `success` and `error` (and so implicitly `message`) can be configured per-action via [the `messages` declaration](/reference/class#messages).

data/docs/reference/class.md

@@ -85,40 +85,148 @@ expects :date, type: Date, preprocess: ->(d) { d.is_a?(Date) ? d : Date.parse(d)
 
 will succeed if given _either_ an actual Date object _or_ a string that Date.parse can convert into one.  If the preprocess callable raises an exception, that'll be swallowed and the action failed.
 
-## `.messages`
+## `.success` and `.error`
 
-The `messages` declaration allows you to customize the `error` and `success` messages on the returned result.
+The `success` and `error` declarations allow you to customize the `error` and `success` messages on the returned result.
 
-Accepts `error` and/or `success` keys.  Values can be a string (returned directly) or a callable (evaluated in the action's context, so can access instance methods).  If `error` is provided with a callable that expects a positional argument, the exception that was raised will be passed in as that value.
+Both methods accept a string (returned directly), a symbol (resolved as a local instance method on the action), or a block (evaluated in the action's context, so can access instance methods and variables).
+
+When an exception is available (e.g., during `error`), handlers can receive it in either of two equivalent ways:
+- Keyword form: accept `exception:` and it will be passed as a keyword
+- Positional form: if the handler accepts a single positional argument, it will be passed positionally
+
+This applies to both blocks and symbol-backed instance methods. Choose the style that best fits your codebase (clarity vs concision).
+
+In callables and symbol-backed methods, you can access:
+- **Input data**: Use field names directly (e.g., `name`)
+- **Output data**: Use `result.field` pattern (e.g., `result.greeting`)
+- **Instance methods and variables**: Direct access
 
 ```ruby
-messages success: "All good!", error: ->(e) { "Bad news: #{e.message}" }
+success { "Hello #{name}, your greeting: #{result.greeting}" }
+error { |e| "Bad news: #{e.message}" }
+error { |exception:| "Bad news: #{exception.message}" }
+
+# Using symbol method names
+success :build_success_message
+error :build_error_message
+
+def build_success_message
+  "Hello #{name}, your greeting: #{result.greeting}"
+end
+
+def build_error_message(e)
+  "Bad news: #{e.message}"
+end
+
+def build_error_message(exception:)
+  "Bad news: #{exception.message}"
+end
 ```
 
-## `error_from` and `rescues`
+## Conditional messages
+
+While `.error` and `.success` set the default messages, you can register conditional messages using an optional `if:` or `unless:` matcher. The matcher can be:
 
-While `.messages` sets the _default_ error/success messages and is more commonly used, there are times when you want specific error messages for specific failure cases.
+- an exception class (e.g., `ArgumentError`)
+- a class name string (e.g., `"Action::InboundValidationError"`)
+- a symbol referencing a local instance method predicate (arity 0 or 1, or keyword `exception:`), e.g. `:bad_input?`
+- a callable (arity 0 or 1, or keyword `exception:`)
 
-`error_from` and `rescues` both register a matcher (exception class, exception class name (string), or callable) and a message to use if the matcher succeeds.  They act exactly the same, except if a matcher registered with `rescues` succeeds, the exception _will not_ trigger the configured exception handlers (global or specific to this class).
+Symbols are resolved as methods on the action instance. If the method accepts `exception:` it will be passed as a keyword; otherwise, if it accepts one positional argument, the raised exception is passed positionally; otherwise it is called with no arguments. If the action does not respond to the symbol, we fall back to constant lookup (e.g., `if: :ArgumentError` behaves like `if: ArgumentError`). Symbols are also supported for the message itself (e.g., `success :method_name`), resolved via the same rules.
 
 ```ruby
-messages error: "bad"
+error "bad"
 
-# Note this will NOT trigger Action.config.on_exception
-rescues ActiveRecord::InvalidRecord => "Invalid params provided"
+# Custom message with exception class matcher
+error "Invalid params provided", if: ActiveRecord::InvalidRecord
 
-# These WILL trigger error handler (second demonstrates callable matcher AND message)
-error_from ArgumentError, ->(e) { "Argument error: #{e.message}" }
-error_from -> { name == "bad" }, -> { "was given bad name: #{name}" }
+# Custom message with callable matcher and message
+error(if: ArgumentError) { |e| "Argument error: #{e.message}" }
+error(if: -> { name == "bad" }) { "Bad input #{name}, result: #{result.status}" }
+
+# Custom message with symbol predicate (arity 0)
+error "Transient error, please retry", if: :transient_error?
+
+def transient_error?
+  # local decision based on inputs/outputs
+  name == "temporary"
+end
+
+# Symbol predicate (arity 1), receives the exception
+error(if: :argument_error?) { |e| "Bad argument: #{e.message}" }
+
+def argument_error?(e)
+  e.is_a?(ArgumentError)
+end
+
+# Symbol predicate (keyword), receives the exception via keyword
+error(if: :argument_error_kw?) { |exception:| "Bad argument: #{exception.message}" }
+
+def argument_error_kw?(exception:)
+  exception.is_a?(ArgumentError)
+end
+
+# Lambda predicate with keyword
+error "AE", if: ->(exception:) { exception.is_a?(ArgumentError) }
+
+# Using unless: for inverse logic
+error "Custom error", unless: :should_skip?
+
+def should_skip?
+  # local decision based on inputs/outputs
+  name == "temporary"
+end
+
+::: warning
+You cannot use both `if:` and `unless:` for the same message - this will raise an `ArgumentError`.
+:::
+
+### Message ordering and inheritance
+
+Messages are evaluated in **last-defined-first** order, meaning the most recently defined message that matches its conditions will be used. This applies to both success and error messages:
+
+```ruby
+class ParentAction
+  include Action
+
+  success "Parent success message"
+  error "Parent error message"
+end
+
+class ChildAction < ParentAction
+  success "Child success message"  # This will be used when action succeeds
+  error "Child error message"      # This will be used when action fails
+end
+```
+
+Within a single class, later definitions override earlier ones:
+
+```ruby
+class MyAction
+  include Action
+
+  success "First success message"           # Ignored
+  success "Second success message"          # Ignored
+  success "Final success message"           # This will be used
+
+  error "First error message"               # Ignored
+  error "Second error message"              # Ignored
+  error "Final error message"               # This will be used
+end
+```
+
+When using conditional messages, the system evaluates handlers in the order defined above until it finds one that matches and doesn't raise an exception. If a handler raises an exception, it falls back to the next matching handler, then to static messages, and finally to the default message.
 ```
 
 ## Callbacks
 
 In addition to the [global exception handler](/reference/configuration#on-exception), a number of custom callback are available for you as well, if you want to take specific actions when a given Axn succeeds or fails.
 
-::: danger ALPHA
-* The callbacks themselves are functional. Note the ordering _between_ callbacks is not well defined (currently a side effect of the order they're defined).
-  * Ordering may change at any time so while in alpha DO NOT MAKE ASSUMPTIONS ABOUT THE ORDER OF CALLBACK EXECUTION!
+::: tip Callback Ordering
+* Callbacks are executed in **last-defined-first** order, similar to messages
+* Child class callbacks execute before parent class callbacks
+* Multiple matching callbacks of the same type will *all* execute
 :::
 
 
@@ -153,17 +261,30 @@ class Foo
 end
 ```
 
-Note that by default the `on_exception` block will be applied to _any_ `StandardError` that is raised, but you can specify a matcher using the same logic as for [`error_from` and `rescues`](#error-for-and-rescues):
+Note that by default the `on_exception` block will be applied to _any_ `StandardError` that is raised, but you can specify a matcher using the same logic as for conditional messages (`if:` or `unless:`):
 
 ```ruby
 class Foo
   include Action
 
-  on_exception NoMethodError do |exception| # [!code focus]
+  on_exception(if: NoMethodError) do |exception| # [!code focus]
     # e.g. trigger a slack error
   end
 
-  on_exception ->(e) { e.is_a?(ZeroDivisionError) } do # [!code focus]
+on_exception(unless: :transient_error?) do |exception| # [!code focus]
+    # e.g. trigger a slack error for non-transient errors
+  end
+
+def transient_error?
+  # local decision based on inputs/outputs
+  name == "temporary"
+end
+
+::: warning
+You cannot use both `if:` and `unless:` for the same callback - this will raise an `ArgumentError`.
+:::
+
+  on_exception(if: ->(e) { e.is_a?(ZeroDivisionError) }) do # [!code focus]
     # e.g. trigger a slack error
   end
 end

data/docs/reference/configuration.md

@@ -4,18 +4,16 @@ Somewhere at boot (e.g. `config/initializers/actions.rb` in Rails), you can call
 
 
 ```ruby
-  Action.configure do |c|
-    c.on_exception = ...
-
-    c.top_level_around_hook = ...
-
-    c.additional_includes = []
-
-    c.default_log_level = :info
-    c.default_autolog_level = :debug
-
-    c.logger = ...
+Action.configure do |c|
+  c.log_level = :info
+  c.logger = ...
+  c.on_exception = proc do |e, action:, context:|
+    message = "[#{action.class.name}] Failing due to #{e.class.name}: #{e.message}"
+
+    Rails.logger.warn(message)
+    Honeybadger.notify(message, context: { axn_context: context })
   end
+end
 ```
 
 ## `on_exception`
@@ -68,7 +66,7 @@ If you're using an APM provider, observability can be greatly enhanced by adding
 The framework provides two distinct hooks for observability:
 
 - **`wrap_with_trace`**: An around hook that wraps the entire action execution. You MUST call the provided block to execute the action.
-- **`emit_metrics`**: A post-execution hook that receives the action outcome. Do NOT call any blocks.
+- **`emit_metrics`**: A post-execution hook that receives the action result. Do NOT call any blocks.
 
 For example, to wire up Datadog:
 
@@ -80,8 +78,9 @@ For example, to wire up Datadog:
       end
     end
 
-    c.emit_metrics = proc do |resource, outcome|
-      TS::Metrics.increment("action.#{resource.underscore}", tags: { outcome:, resource: })
+    c.emit_metrics = proc do |resource, result|
+      TS::Metrics.increment("action.#{resource.underscore}", tags: { outcome: result.outcome, resource: })
+      TS::Metrics.histogram("action.duration", result.elapsed_time, tags: { resource: })
     end
   end
 ```
@@ -89,9 +88,9 @@ For example, to wire up Datadog:
 A couple notes:
 
   * `Datadog::Tracing` is provided by [the datadog gem](https://rubygems.org/gems/datadog)
-  * `TS::Metrics` is a custom implementation to set a Datadog count metric, but the relevant part to note is that outcome (`success`, `failure`, `exception`) of the action is reported so you can easily track e.g. success rates per action.
+  * `TS::Metrics` is a custom implementation to set a Datadog count metric, but the relevant part to note is that the result object provides access to the outcome (`success`, `failure`, `exception`) and elapsed time of the action.
   * The `wrap_with_trace` hook is an around hook - you must call the provided block to execute the action
-  * The `emit_metrics` hook is called after execution with the outcome - do not call any blocks
+  * The `emit_metrics` hook is called after execution with the result - do not call any blocks
 
 
 ## `logger`
@@ -112,11 +111,11 @@ For example:
 
 For a practical example of this in practice, see [our 'memoization' recipe](/recipes/memoization).
 
-## `default_log_level`
+## `log_level`
 
-Sets the log level used when you call `log "Some message"` in your Action.  Note this is read via a `default_log_level` class method, so you can easily use inheritance to support different log levels for different sets of actions.
+Sets the log level used when you call `log "Some message"` in your Action.  Note this is read via a `log_level` class method, so you can easily use inheritance to support different log levels for different sets of actions.
 
-## `default_autolog_level`
+## Automatic Logging
 
 By default, every `action.call` will emit log lines when it is called and after it completes:
 
@@ -125,4 +124,27 @@ By default, every `action.call` will emit log lines when it is called and after
     [YourCustomAction] Execution completed (with outcome: success) in 0.957 milliseconds
   ```
 
-You can change the default _auto_-log level separately from the log level used for your explicit `log` calls (just like above, via Action.config or a `default_autolog_level` class method).
+Automatic logging will log at `Action.config.log_level` by default, but can be overridden or disabled using the declarative `auto_log` method:
+
+```ruby
+# Set default for all actions (affects both explicit logging and automatic logging)
+Action.configure do |c|
+  c.log_level = :debug
+end
+
+# Override for specific actions
+class MyAction
+  auto_log :warn  # Use warn level for this action
+end
+
+class SilentAction
+  auto_log false  # Disable automatic logging for this action
+end
+
+# Use default level (no auto_log call needed)
+class DefaultAction
+  # Uses Action.config.log_level
+end
+```
+
+The `auto_log` method supports inheritance, so subclasses will inherit the setting from their parent class unless explicitly overridden.

data/docs/usage/writing.md

@@ -79,7 +79,7 @@ class Foo
   expects :name, type: String
   exposes :meaning_of_life
 
-  messages success: -> { "Revealed the secret of life to #{name}" }, # [!code focus:2]
+  messages success: -> { "Revealed to #{name}: #{result.meaning_of_life}" }, # [!code focus:2]
            error: ->(e) { "No secret of life for you: #{e.message}" }
 
   def call

data/lib/action/attachable/steps.rb

@@ -38,10 +38,25 @@ module Action
           step = Entry.new(label: "Step #{idx + 1}", axn: step) if step.is_a?(Class)
 
           hoist_errors(prefix: "#{step.label} step") do
-            step.axn.call(@context)
+            step.axn.call(**merged_context_data).tap do |step_result|
+              merge_step_exposures!(step_result)
+            end
           end
         end
       end
+
+      private
+
+      def merged_context_data
+        @__context.__combined_data
+      end
+
+      # Each step can expect the data exposed from the previous steps
+      def merge_step_exposures!(step_result)
+        step_result.declared_fields.each do |field|
+          @__context.exposed_data[field] = step_result.public_send(field)
+        end
+      end
     end
   end
 end

data/lib/action/configuration.rb

@@ -3,10 +3,9 @@
 module Action
   class Configuration
     attr_accessor :wrap_with_trace, :emit_metrics
-    attr_writer :logger, :env, :on_exception, :additional_includes, :default_log_level, :default_autolog_level
+    attr_writer :logger, :env, :on_exception, :additional_includes, :log_level
 
-    def default_log_level = @default_log_level ||= :info
-    def default_autolog_level = @default_autolog_level ||= :info
+    def log_level = @log_level ||= :info
 
     def additional_includes = @additional_includes ||= []
 

data/lib/action/context.rb

@@ -1,28 +1,38 @@
 # frozen_string_literal: true
 
-# NOTE: This is a temporary file to be removed when we have a better way to handle context.
-# rubocop:disable Style/OpenStructUse, Style/CaseEquality
-require "ostruct"
-
 module Action
-  class Context < OpenStruct
-    def self.build(context = {})
-      self === context ? context : new(context)
-    end
+  class Context
+    attr_accessor :provided_data, :exposed_data
 
-    def success?
-      !failure?
-    end
+    def initialize(**provided_data)
+      @provided_data = provided_data
+      @exposed_data = {}
 
-    def failure?
-      @failure || false
+      # Framework-managed fields
+      @failure = false
+      @exception = nil
+      @error_from_user = nil
+      @error_prefix = nil
+      @elapsed_time = nil
     end
 
-    def fail!(context = {})
-      context.each { |key, value| self[key.to_sym] = value }
-      @failure = true
-      raise Action::Failure, self
+    def fail!(message = nil)
+      @error_from_user = message if message.present?
+      raise Action::Failure, message
     end
+
+    # INTERNAL: base for further filtering (for logging) or providing user with usage hints
+    def __combined_data = @provided_data.merge(@exposed_data)
+
+    # Framework state methods
+    def ok? = !@failure
+    def failed? = @failure || false
+
+    # Framework field accessors
+    attr_accessor :exception, :error_from_user, :error_prefix, :elapsed_time
+
+    # Internal failure state setter (for framework use)
+    attr_writer :failure
+    private :failure=
   end
 end
-# rubocop:enable Style/OpenStructUse, Style/CaseEquality

data/lib/action/core/automatic_logging.rb

@@ -7,19 +7,34 @@ module Action
         base.class_eval do
           extend ClassMethods
           include InstanceMethods
+
+          # Single class_attribute - nil means disabled, any level means enabled
+          class_attribute :auto_log_level, default: Action.config.log_level
         end
       end
 
       module ClassMethods
-        def autolog_level = Action.config.default_autolog_level
+        def auto_log(level)
+          self.auto_log_level = level.presence
+        end
       end
 
       module InstanceMethods
         private
 
+        def _with_logging
+          _log_before if self.class.auto_log_level
+          yield
+        ensure
+          _log_after if self.class.auto_log_level
+        end
+
         def _log_before
-          public_send(
-            self.class.autolog_level,
+          level = self.class.auto_log_level
+          return unless level
+
+          self.class.public_send(
+            level,
             [
               "About to execute",
               _log_context(:inbound),
@@ -30,13 +45,14 @@ module Action
           Axn::Util.piping_error("logging before hook", action: self, exception: e)
         end
 
-        def _log_after(outcome:, timing_start:)
-          elapsed_mils = Core::Timing.elapsed_ms(timing_start)
+        def _log_after
+          level = self.class.auto_log_level
+          return unless level
 
-          public_send(
-            self.class.autolog_level,
+          self.class.public_send(
+            level,
             [
-              "Execution completed (with outcome: #{outcome}) in #{elapsed_mils} milliseconds",
+              "Execution completed (with outcome: #{result.outcome}) in #{result.elapsed_time} milliseconds",
               _log_context(:outbound),
             ].compact.join(". Set: "),
             after: Action.config.env.production? ? nil : "\n------\n",

data/lib/action/core/context/facade.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "active_support/parameter_filter"
+
+module Action
+  class ContextFacade
+    def initialize(action:, context:, declared_fields:, implicitly_allowed_fields: nil)
+      if self.class.name == "Action::ContextFacade" # rubocop:disable Style/ClassEqualityComparison
+        raise "Action::ContextFacade is an abstract class and should not be instantiated directly"
+      end
+
+      @context = context
+      @action = action
+      @declared_fields = declared_fields
+
+      (@declared_fields + Array(implicitly_allowed_fields)).each do |field|
+        singleton_class.define_method(field) do
+          context_data_source[field]
+        end
+      end
+    end
+
+    attr_reader :declared_fields
+
+    def inspect = ContextFacadeInspector.new(facade: self, action:, context:).call
+
+    def fail!(...)
+      raise Action::ContractViolation::MethodNotAllowed, "Call fail! directly rather than on the context"
+    end
+
+    private
+
+    attr_reader :action, :context
+
+    def action_name = @action.class.name.presence || "The action"
+
+    def context_data_source = raise NotImplementedError
+  end
+end

data/lib/action/core/context/facade_inspector.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Action
+  class ContextFacadeInspector
+    def initialize(action:, facade:, context:)
+      @action = action
+      @facade = facade
+      @context = context
+    end
+
+    def call
+      str = [status, visible_fields].compact_blank.join(" ")
+
+      "#<#{class_name} #{str}>"
+    end
+
+    private
+
+    attr_reader :action, :facade, :context
+
+    def status
+      return unless facade.is_a?(Action::Result)
+
+      return "[OK]" if context.ok?
+      unless context.exception
+        return context.error_from_user.present? ? "[failed with '#{context.error_from_user}']" : "[failed]"
+      end
+
+      %([failed with #{context.exception.class.name}: '#{context.exception.message}'])
+    end
+
+    def visible_fields
+      declared_fields.map do |field|
+        value = facade.public_send(field)
+
+        "#{field}: #{format_for_inspect(field, value)}"
+      end.join(", ")
+    end
+
+    def class_name = facade.class.name
+    def declared_fields = facade.send(:declared_fields)
+
+    def format_for_inspect(field, value)
+      return value.inspect if value.nil?
+
+      # Initially based on https://github.com/rails/rails/blob/800976975253be2912d09a80757ee70a2bb1e984/activerecord/lib/active_record/attribute_methods.rb#L527
+      inspected_value = if value.is_a?(String) && value.length > 50
+                          "#{value[0, 50]}...".inspect
+                        elsif value.is_a?(Date) || value.is_a?(Time)
+                          %("#{value.to_fs(:inspect)}")
+                        elsif defined?(::ActiveRecord::Relation) && value.instance_of?(::ActiveRecord::Relation)
+                          # Avoid hydrating full AR relation (i.e. avoid loading records just to report an error)
+                          "#{value.name}::ActiveRecord_Relation"
+                        else
+                          value.inspect
+                        end
+
+      inspection_filter.filter_param(field, inspected_value)
+    end
+
+    def inspection_filter = action.send(:inspection_filter)
+  end
+end