axn 0.1.0.pre.alpha.2.5.3.1 → 0.1.0.pre.alpha.2.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d67c51bf6cef09cdbfb8246769eefb7c9b1baa3f7d75168d599f898d66d00157
-  data.tar.gz: 06d6b82b58b9a65bd1d8da9e68a8a640a5fcf0e1dafdbd5d756ea1d1682f7e95
+  metadata.gz: 30c00229f0062bdba5979d0e69de4ffddb6bece3f31413f83b7f7778d3075ef7
+  data.tar.gz: 92d944caf300ddfc9a134d34ae2cb73e6d235e0af9f7a10a3ee93065ae834690
 SHA512:
-  metadata.gz: a656fe06eec316eb1c974586adec336afe6f09257da62f88789f467fe06f0f3677249fccb1aec7dd83c3328c1cc0ee505640e786b1892338ff0be71723b758c3
-  data.tar.gz: 337a92138da80dcf5e00947b4cb00589d689e1dc6dae3340d91e76874e4a335feb3a1ef254c3e6220c6a0d271f49fe8f77f9deea5d731ed1caa3f3c4317c1b42
+  metadata.gz: 600b1572f324b8cbbaf2b5dd48108546db86e63e3c7d49a04e1eb9f0f2e83720eafdaabb94ccf0550ff1c0e63b3ec555950443eb5c064698dbc65cf97c2b1733
+  data.tar.gz: e9229f25cd10dcc54f1f7c5b83ff81b997d96263296818caaf2cfc245fde93ab24d7f0605700ea042c085ab7456f5fc1b20c2cc643324609bc0f4662ecbdcd21

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

@@ -3,6 +3,30 @@
 ## Unreleased
 * N/A
 
+## 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)
+  * Refactor internals to clean implementation now that we have direct control
+  * [BREAKING] Replaced `Action.config.top_level_around_hook` with `.wrap_with_trace` and `.emit_metrics`
+  * [BREAKING] the order of hooks with inheritance has changed to more intuitively follow the natural pattern of setup (general → specific) and teardown (specific → general):
+    * **Before hooks**: Parent → Child (general setup first, then specific)
+    * **After hooks**: Child → Parent (specific cleanup first, then general)
+    * **Around hooks**: Parent wraps child (parent outside, child inside)
+* Removed non-functional #rollback traces (use on_exception hook instead)
+* Clean requires structure
+
 ## 0.1.0-alpha.2.5.3.1
 * Remove explicit 'require rspec' from `axn/testing/spec_helpers` (must already be loaded)
 
@@ -13,7 +37,7 @@
 ## 0.1.0-alpha.2.5.2
 * [BREAKING] Removing `EnqueueAllInBackground` + `EnqueueAllWorker` - better + simply solved at application level
 * [TEST] Expose spec helpers to consumers (add `require "axn/testing/spec_helpers"` to your `spec_helper.rb`)
-# [FEAT] Added ability to use custom Strategies (via e.g. `use :transaction`)
+* [FEAT] Added ability to use custom Strategies (via e.g. `use :transaction`)
 
 ## 0.1.0-alpha.2.5.1.2
 * [BUGFIX] Subfield expectations: now support hashes with string keys (using with_indifferent_access)

data/README.md

@@ -1,20 +1,11 @@
 # Axn -- [AHK-sin] (a.k.a. "Action")
 
-Just spinning this up -- not yet released (i.e. doc updates in flight).
+Just spinning this up -- not yet publicly released, changes coming frequently.
 
 ## Installation & Usage
 
 See our [User Guide](https://teamshares.github.io/axn/) for details.
 
-## [!!] Inheritance Support
-
-Out of the box Axn only supports a direct style (every action must `include Action`).
-
-If you want to support inheritance, you'll need to add this line to your `Gemfile` (we're layered over Interactor, and their released version doesn't yet support inheritance):
-
-    gem "interactor", github: "kaspermeyer/interactor", branch: "fix-hook-inheritance"
-
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -27,4 +18,4 @@ See our [contribution guidelines](CONTRIBUTING.md) for more information.
 
 ## Thank You
 
-A very special thank you to [Collective Idea](https://collectiveidea.com/)'s fantastic [Interactor](https://github.com/collectiveidea/interactor?tab=readme-ov-file#interactor) library, which [we](https://www.teamshares.com/) used successfully for a number of years and which still forms the basis of this library today.
+A very special thank you to [Collective Idea](https://collectiveidea.com/)'s fantastic [Interactor](https://github.com/collectiveidea/interactor?tab=readme-ov-file#interactor) library, which [we](https://www.teamshares.com/) used successfully for a number of years and which we used to scaffold early versions of this library.

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

@@ -89,10 +89,16 @@ will succeed if given _either_ an actual Date object _or_ a string that Date.par
 
 The `messages` declaration allows 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.
+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 and variables).  If `error` is provided with a callable that expects a positional argument, the exception that was raised will be passed in as that value.
+
+In callables, 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}" }
+messages success: -> { "Hello #{name}, your greeting: #{result.greeting}" },
+         error: ->(e) { "Bad news: #{e.message}" }
 ```
 
 ## `error_from` and `rescues`
@@ -101,15 +107,17 @@ While `.messages` sets the _default_ error/success messages and is more commonly
 
 `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).
 
+Callable matchers and messages follow the same data access patterns as other callables: input fields directly, output fields via `result.field`, instance variables, and methods.
+
 ```ruby
 messages error: "bad"
 
 # Note this will NOT trigger Action.config.on_exception
 rescues ActiveRecord::InvalidRecord => "Invalid params provided"
 
-# These WILL trigger error handler (second demonstrates callable matcher AND message)
+# These WILL trigger error handler (callable matcher + message with data access)
 error_from ArgumentError, ->(e) { "Argument error: #{e.message}" }
-error_from -> { name == "bad" }, -> { "was given bad name: #{name}" }
+error_from -> { name == "bad" }, -> { "Bad input #{name}, result: #{result.status}" }
 ```
 
 ## Callbacks

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`
@@ -63,24 +61,36 @@ A couple notes:
 
 If you're using an APM provider, observability can be greatly enhanced by adding automatic _tracing_ of Action calls and/or emitting count metrics after each call completes.
 
+### Tracing and Metrics
+
+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 result. Do NOT call any blocks.
+
 For example, to wire up Datadog:
 
 ```ruby
   Action.configure do |c|
-    c.top_level_around_hook = proc do |resource, &action|
+    c.wrap_with_trace = proc do |resource, &action|
       Datadog::Tracing.trace("Action", resource:) do
-        (outcome, _exception) = action.call
-
-        TS::Metrics.increment("action.#{resource.underscore}", tags: { outcome:, resource: })
+        action.call
       end
     end
+
+    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
 ```
 
 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 result - do not call any blocks
 
 
 ## `logger`
@@ -101,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:
 
@@ -114,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/reference/instance.md

@@ -12,7 +12,7 @@ Primarily used for its side effects, but it does return a Hash with the key/valu
 
 ## `#fail!`
 
-Called with a string, it immediately halts execution (including triggering any [rollback handler](/reference/class#rollback) you have defined) and sets `result.error` to the provided string.
+Called with a string, it immediately halts execution and sets `result.error` to the provided string.
 
 ## `#log`
 
@@ -31,7 +31,7 @@ A few details:
 * An explicit `fail!` call _will_ still fail the action
 * Any exceptions swallowed _will_ still be reported via the `on_exception` handler
 
-This is primarily useful in an after block, e.g. trigger notifications after an action has been taken.  If the notification fails to send you DO want to log the failure somewhere to investigate, but since the core action has already been taken often you do _not_ want to fail and roll back.
+This is primarily useful in an after block, e.g. trigger notifications after an action has been taken.  If the notification fails to send you DO want to log the failure somewhere to investigate, but since the core action has already been taken often you do _not_ want to fail.
 
 Example:
 

data/docs/strategies/index.md

@@ -155,7 +155,7 @@ Action::Strategies.register(:retry, RetryStrategy)
 
 ### Example: Complete Custom Strategy
 
-Here's a complete example of a custom strategy that adds performance monitoring:
+Here's a complete example of a custom strategy that adds performance monitoring (note Axn already logs elapsed time, this is just a toy example):
 
 ```ruby
 module PerformanceMonitoringStrategy

data/docs/usage/setup.md

@@ -19,6 +19,6 @@ By default any swallowed errors are noted in the logs, but it's _highly recommen
 
 ### Metrics / Tracing
 
-If you're using an APM provider, observability can be greatly enhanced by [configuring a `top_level_around_hook`](/reference/configuration#top-level-around-hook).
+If you're using an APM provider, observability can be greatly enhanced by [configuring tracing and metrics hooks](/reference/configuration#tracing-and-metrics).
 
 

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
@@ -104,18 +104,11 @@ Foo.call(name: "Adams").meaning_of_life # => "Hello Adams, the meaning of life i
 
 In addition to `#call`, there are a few additional pieces to be aware of:
 
-<!-- ### `#rollback`
-*** TODO: rollback actually only applies to rolling back *completed* steps of a multi-step Axn chain.  Do not document for now -- need to decide if adding a trigger-when-axn-itself-fails rollback path. ***
 
-::: danger ALPHA
-* ⚠️ `#rollback` is _expected_ to be added shortly, but is not yet functional!
-:::
-
-If you define a `#rollback` method, it'll be called (_before_ returning an `Action::Result` to the caller) whenever your action fails. -->
 
 ### Hooks
 
-`before` and `after` hooks are supported. They can receive a block directly, or the symbol name of a local method.
+`before`, `after`, and `around` hooks are supported. They can receive a block directly, or the symbol name of a local method.
 
 Note execution is halted whenever `fail!` is called or an exception is raised (so a `before` block failure won't execute `call` or `after`, while an `after` block failure will make `result.ok?` be false even though `call` completed successfully).
 
@@ -150,6 +143,13 @@ in call
 after hook
 ```
 
+**Hook Ordering with Inheritance:**
+- **Around hooks**: Parent wraps child (parent outside, child inside)
+- **Before hooks**: Parent → Child (general setup first, then specific)
+- **After hooks**: Child → Parent (specific cleanup first, then general)
+
+This follows the natural pattern of setup (general → specific) and teardown (specific → general).
+
 ### Callbacks
 
 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. See the [Class Interface docs](/reference/class#callbacks) for details.

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/attachable.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "attachable/base"
-require_relative "attachable/steps"
-require_relative "attachable/subactions"
+require "action/attachable/base"
+require "action/attachable/steps"
+require "action/attachable/subactions"
 
 module Action
   module Attachable

data/lib/action/{core/configuration.rb → configuration.rb}

@@ -2,11 +2,10 @@
 
 module Action
   class Configuration
-    attr_accessor :top_level_around_hook
-    attr_writer :logger, :env, :on_exception, :additional_includes, :default_log_level, :default_autolog_level
+    attr_accessor :wrap_with_trace, :emit_metrics
+    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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Action
+  class Context
+    attr_accessor :provided_data, :exposed_data
+
+    def initialize(**provided_data)
+      @provided_data = provided_data
+      @exposed_data = {}
+
+      # Framework-managed fields
+      @failure = false
+      @exception = nil
+      @error_from_user = nil
+      @error_prefix = nil
+      @elapsed_time = nil
+    end
+
+    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

data/lib/action/core/automatic_logging.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Action
+  module Core
+    module AutomaticLogging
+      def self.included(base)
+        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 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
+          level = self.class.auto_log_level
+          return unless level
+
+          self.class.public_send(
+            level,
+            [
+              "About to execute",
+              _log_context(:inbound),
+            ].compact.join(" with: "),
+            before: Action.config.env.production? ? nil : "\n------\n",
+          )
+        rescue StandardError => e
+          Axn::Util.piping_error("logging before hook", action: self, exception: e)
+        end
+
+        def _log_after
+          level = self.class.auto_log_level
+          return unless level
+
+          self.class.public_send(
+            level,
+            [
+              "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",
+          )
+        rescue StandardError => e
+          Axn::Util.piping_error("logging after hook", action: self, exception: e)
+        end
+
+        def _log_context(direction)
+          data = context_for_logging(direction)
+          return unless data.present?
+
+          max_length = 150
+          suffix = "…<truncated>…"
+
+          _log_object(data).tap do |str|
+            return str[0, max_length - suffix.length] + suffix if str.length > max_length
+          end
+        end
+
+        def _log_object(data)
+          case data
+          when Hash
+            # NOTE: slightly more manual in order to avoid quotes around ActiveRecord objects' <Class#id> formatting
+            "{#{data.map { |k, v| "#{k}: #{_log_object(v)}" }.join(", ")}}"
+          when Array
+            data.map { |v| _log_object(v) }
+          else
+            return data.to_unsafe_h if defined?(ActionController::Parameters) && data.is_a?(ActionController::Parameters)
+            return "<#{data.class.name}##{data.to_param.presence || "unpersisted"}>" if defined?(ActiveRecord::Base) && data.is_a?(ActiveRecord::Base)
+
+            data.inspect
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# 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
+
+    def determine_error_message(only_default: false)
+      return @context.error_from_user if @context.error_from_user.present?
+
+      # We need an exception for interceptors, and also in case the messages.error callable expects an argument
+      exception = @context.exception || Action::Failure.new
+
+      msg = action._error_msg
+
+      unless only_default
+        interceptor = action.class._error_interceptor_for(exception:, action:)
+        msg = interceptor.message if interceptor
+      end
+
+      stringified(msg, exception:).presence || "Something went wrong"
+    end
+
+    # Allow for callable OR string messages
+    def stringified(msg, exception: nil)
+      return msg.presence unless msg.respond_to?(:call)
+
+      # The error message callable can take the exception as an argument
+      if exception && msg.arity == 1
+        action.instance_exec(exception, &msg)
+      else
+        action.instance_exec(&msg)
+      end
+    rescue StandardError => e
+      Axn::Util.piping_error("determining message callable", action:, exception: e)
+    end
+  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