axn 0.1.0.pre.alpha.3 → 0.1.0.pre.alpha.4

data/lib/axn/core/automatic_logging.rb

@@ -9,13 +9,18 @@ module Axn
           include InstanceMethods
 
           # Single class_attribute - nil means disabled, any level means enabled
-          class_attribute :auto_log_level, default: Axn.config.log_level
+          class_attribute :log_calls_level, default: Axn.config.log_level
+          class_attribute :log_errors_level, default: nil
         end
       end
 
       module ClassMethods
-        def auto_log(level)
-          self.auto_log_level = level.presence
+        def log_calls(level)
+          self.log_calls_level = level.presence
+        end
+
+        def log_errors(level)
+          self.log_errors_level = level.presence
         end
       end
 
@@ -23,69 +28,60 @@ module Axn
         private
 
         def _with_logging
-          _log_before if self.class.auto_log_level
+          _log_before if self.class.log_calls_level
           yield
         ensure
-          _log_after if self.class.auto_log_level
+          _log_after if self.class.log_calls_level || self.class.log_errors_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: Axn.config.env.production? ? nil : "\n------\n",
+          Axn::Util::Logging.log_at_level(
+            self.class,
+            level: self.class.log_calls_level,
+            message_parts: ["About to execute"],
+            join_string: " with: ",
+            before: _top_level_separator,
+            error_context: "logging before hook",
+            context_direction: :inbound,
+            context_instance: self,
           )
-        rescue StandardError => e
-          Axn::Internal::Logging.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: Axn.config.env.production? ? nil : "\n------\n",
-          )
-        rescue StandardError => e
-          Axn::Internal::Logging.piping_error("logging after hook", action: self, exception: e)
-        end
+          # Check log_calls_level first (logs all outcomes)
+          if self.class.log_calls_level
+            _log_after_at_level(self.class.log_calls_level)
+            return
+          end
 
-        def _log_context(direction)
-          data = context_for_logging(direction)
-          return unless data.present?
+          # Check log_errors_level (only logs when result.ok? is false)
+          return unless self.class.log_errors_level && !result.ok?
 
-          max_length = 150
-          suffix = "…<truncated>…"
+          _log_after_at_level(self.class.log_errors_level)
+        end
 
-          _log_object(data).tap do |str|
-            return str[0, max_length - suffix.length] + suffix if str.length > max_length
-          end
+        def _log_after_at_level(level)
+          Axn::Util::Logging.log_at_level(
+            self.class,
+            level:,
+            message_parts: [
+              "Execution completed (with outcome: #{result.outcome}) in #{result.elapsed_time} milliseconds",
+            ],
+            join_string: ". Set: ",
+            after: _top_level_separator,
+            error_context: "logging after hook",
+            context_direction: :outbound,
+            context_instance: self,
+          )
         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)
+        def _top_level_separator
+          return if Axn.config.env.production?
+          return if Axn::Util::ExecutionContext.background?
+          return if Axn::Util::ExecutionContext.console?
+          return if NestingTracking._current_axn_stack.size > 1
 
-            data.inspect
-          end
+          "\n------\n"
         end
       end
     end

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

@@ -65,7 +65,7 @@ module Axn
       inspection_filter.filter_param(field, inspected_value)
     end
 
-    def inspection_filter = action.send(:inspection_filter)
+    def inspection_filter = action.class.inspection_filter
 
     def sensitive_subfields?(field)
       action.subfield_configs.any? { |config| config.on == field && config.sensitive }

data/lib/axn/core/contract.rb

@@ -41,7 +41,7 @@ module Axn
 
           _parse_field_configs(*fields, allow_blank:, allow_nil:, optional:, default:, preprocess:, sensitive:, **validations).tap do |configs|
             duplicated = internal_field_configs.map(&:field) & configs.map(&:field)
-            raise Axn::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
+            raise Axn::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(', ')}" if duplicated.any?
 
             # NOTE: avoid <<, which would update value for parents and children
             self.internal_field_configs += configs
@@ -63,13 +63,37 @@ module Axn
 
           _parse_field_configs(*fields, allow_blank:, allow_nil:, optional:, default:, preprocess: nil, sensitive:, **validations).tap do |configs|
             duplicated = external_field_configs.map(&:field) & configs.map(&:field)
-            raise Axn::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
+            raise Axn::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(', ')}" if duplicated.any?
 
             # NOTE: avoid <<, which would update value for parents and children
             self.external_field_configs += configs
           end
         end
 
+        def inspection_filter
+          @inspection_filter ||= ActiveSupport::ParameterFilter.new(sensitive_fields)
+        end
+
+        def sensitive_fields
+          (internal_field_configs + external_field_configs + subfield_configs).select(&:sensitive).map(&:field)
+        end
+
+        def _declared_fields(direction)
+          raise ArgumentError, "Invalid direction: #{direction}" unless direction.nil? || %i[inbound outbound].include?(direction)
+
+          configs = case direction
+                    when :inbound then internal_field_configs
+                    when :outbound then external_field_configs
+                    else (internal_field_configs + external_field_configs)
+                    end
+
+          configs.map(&:field)
+        end
+
+        def context_for_logging(data:, direction: nil)
+          inspection_filter.filter(data.slice(*_declared_fields(direction)))
+        end
+
         private
 
         RESERVED_FIELD_NAMES_FOR_EXPECTATIONS = %w[
@@ -169,54 +193,73 @@ module Axn
           end
         end
 
+        # Set additional context to be included in exception logging
+        # This context is only used when exceptions occur, not in normal pre/post logging
+        def set_logging_context(**kwargs)
+          @__additional_logging_context ||= {}
+          @__additional_logging_context.merge!(kwargs)
+        end
+
+        # Clear any previously set additional logging context
+        def clear_logging_context
+          @__additional_logging_context = nil
+        end
+
         def context_for_logging(direction = nil)
-          inspection_filter.filter(@__context.__combined_data.slice(*_declared_fields(direction)))
+          base_context = self.class.context_for_logging(
+            data: @__context.__combined_data,
+            direction:,
+          )
+
+          # Only merge additional context for exception logging (direction is nil)
+          # Pre/post logging don't need additional context since they only log inputs/outputs
+          return base_context if direction
+
+          # Merge both explicit setter context and hook method context (if both exist)
+          explicit_context = @__additional_logging_context || {}
+          hook_context = respond_to?(:additional_logging_context, true) ? additional_logging_context : {}
+          base_context.merge(explicit_context).merge(hook_context)
         end
 
         private
 
-        def _with_contract
-          _apply_inbound_preprocessing!
-          _apply_defaults!(:inbound)
+        def _handle_early_completion_if_raised
+          yield
+          nil
+        rescue Axn::Internal::EarlyCompletion => e
+          @__context.__record_early_completion(e.message)
+          _trigger_on_success
+          true
+        end
+
+        def _with_contract(&)
+          return if _handle_early_completion_if_raised { _apply_inbound_preprocessing! }
+          return if _handle_early_completion_if_raised { _apply_defaults!(:inbound) }
+
           _validate_contract!(:inbound)
 
-          yield
+          if _handle_early_completion_if_raised(&)
+            # Even with early completion, we need to validate outbound and apply defaults
+            _apply_defaults!(:outbound)
+            _validate_contract!(:outbound)
+            return
+          end
 
           _apply_defaults!(:outbound)
           _validate_contract!(:outbound)
 
           # TODO: improve location of this triggering
           @__context.__finalize! # Mark result as finalized
-          _trigger_on_success if respond_to?(:_trigger_on_success)
+          _trigger_on_success
         end
 
         def _build_context_facade(direction)
           raise ArgumentError, "Invalid direction: #{direction}" unless %i[inbound outbound].include?(direction)
 
           klass = direction == :inbound ? Axn::InternalContext : Axn::Result
-          implicitly_allowed_fields = direction == :inbound ? _declared_fields(:outbound) : []
-
-          klass.new(action: self, context: @__context, declared_fields: _declared_fields(direction), implicitly_allowed_fields:)
-        end
-
-        def inspection_filter
-          @inspection_filter ||= ActiveSupport::ParameterFilter.new(sensitive_fields)
-        end
-
-        def sensitive_fields
-          (internal_field_configs + external_field_configs + subfield_configs).select(&:sensitive).map(&:field)
-        end
+          implicitly_allowed_fields = direction == :inbound ? self.class._declared_fields(:outbound) : []
 
-        def _declared_fields(direction)
-          raise ArgumentError, "Invalid direction: #{direction}" unless direction.nil? || %i[inbound outbound].include?(direction)
-
-          configs = case direction
-                    when :inbound then internal_field_configs
-                    when :outbound then external_field_configs
-                    else (internal_field_configs + external_field_configs)
-                    end
-
-          configs.map(&:field)
+          klass.new(action: self, context: @__context, declared_fields: self.class._declared_fields(direction), implicitly_allowed_fields:)
         end
       end
     end

data/lib/axn/core/contract_for_subfields.rb

@@ -39,7 +39,7 @@ module Axn
           _parse_subfield_configs(*fields, on:, readers:, allow_blank:, allow_nil:, optional:, preprocess:, sensitive:, default:,
                                            **validations).tap do |configs|
             duplicated = subfield_configs.map(&:field) & configs.map(&:field)
-            raise Axn::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
+            raise Axn::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(', ')}" if duplicated.any?
 
             # NOTE: avoid <<, which would update value for parents and children
             self.subfield_configs += configs

data/lib/axn/core/contract_validation.rb

@@ -10,10 +10,13 @@ module Axn
           next unless config.preprocess
 
           initial_value = @__context.provided_data[config.field]
-          new_value = config.preprocess.call(initial_value)
-          @__context.provided_data[config.field] = new_value
-        rescue StandardError => e
-          raise Axn::ContractViolation::PreprocessingError, "Error preprocessing field '#{config.field}': #{e.message}", cause: e
+          @__context.provided_data[config.field] = Axn::Util::ContractErrorHandling.with_contract_error_handling(
+            exception_class: Axn::ContractViolation::PreprocessingError,
+            message: ->(field, error) { "Error preprocessing field '#{field}': #{error.message}" },
+            field_identifier: config.field,
+          ) do
+            instance_exec(initial_value, &config.preprocess)
+          end
         end
 
         _apply_inbound_preprocessing_for_subfields!
@@ -57,11 +60,13 @@ module Axn
           data_hash = direction == :inbound ? @__context.provided_data : @__context.exposed_data
           next if data_hash.key?(field) && !data_hash[field].nil?
 
-          default_value = default_value_getter.respond_to?(:call) ? instance_exec(&default_value_getter) : default_value_getter
-
-          data_hash[field] = default_value
-        rescue StandardError => e
-          raise Axn::ContractViolation::DefaultAssignmentError, "Error applying default for field '#{field}': #{e.message}", cause: e
+          data_hash[field] = Axn::Util::ContractErrorHandling.with_contract_error_handling(
+            exception_class: Axn::ContractViolation::DefaultAssignmentError,
+            message: ->(field_name, error) { "Error applying default for field '#{field_name}': #{error.message}" },
+            field_identifier: field,
+          ) do
+            default_value_getter.respond_to?(:call) ? instance_exec(&default_value_getter) : default_value_getter
+          end
         end
 
         # Apply subfield defaults for inbound direction

data/lib/axn/core/contract_validation_for_subfields.rb

@@ -9,10 +9,14 @@ module Axn
       def _apply_inbound_preprocessing_for_subfields!
         _for_each_relevant_subfield_config(:preprocess) do |config, parent_field, subfield, parent_value|
           current_subfield_value = Axn::Core::FieldResolvers.resolve(type: :extract, field: subfield, provided_data: parent_value)
-          preprocessed_value = config.preprocess.call(current_subfield_value)
+          preprocessed_value = Axn::Util::ContractErrorHandling.with_contract_error_handling(
+            exception_class: Axn::ContractViolation::PreprocessingError,
+            message: ->(_field, error) { "Error preprocessing subfield '#{config.field}' on '#{config.on}': #{error.message}" },
+            field_identifier: "#{config.field} on #{config.on}",
+          ) do
+            instance_exec(current_subfield_value, &config.preprocess)
+          end
           _update_subfield_value(parent_field, subfield, preprocessed_value)
-        rescue StandardError => e
-          raise Axn::ContractViolation::PreprocessingError, "Error preprocessing subfield '#{config.field}' on '#{config.on}': #{e.message}", cause: e
         end
       end
 
@@ -23,11 +27,14 @@ module Axn
 
           @__context.provided_data[parent_field] = {} if parent_value.nil?
 
-          default_value = config.default.respond_to?(:call) ? instance_exec(&config.default) : config.default
+          default_value = Axn::Util::ContractErrorHandling.with_contract_error_handling(
+            exception_class: Axn::ContractViolation::DefaultAssignmentError,
+            message: ->(_field, error) { "Error applying default for subfield '#{config.field}' on '#{config.on}': #{error.message}" },
+            field_identifier: "#{config.field} on #{config.on}",
+          ) do
+            config.default.respond_to?(:call) ? instance_exec(&config.default) : config.default
+          end
           _update_subfield_value(parent_field, subfield, default_value)
-        rescue StandardError => e
-          raise Axn::ContractViolation::DefaultAssignmentError, "Error applying default for subfield '#{config.field}' on '#{config.on}': #{e.message}",
-                cause: e
         end
       end
 

data/lib/axn/core/default_call.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Axn
+  module Core
+    # Default implementation of the call method that automatically exposes
+    # all declared exposures by calling methods with matching names.
+    module DefaultCall
+      # User-defined action logic - override this method in your action classes
+      # Default implementation automatically exposes all declared exposures by calling
+      # methods with matching names. Raises if a method is missing and no default is provided.
+      def call
+        return if self.class.external_field_configs.empty?
+
+        exposures = {}
+
+        self.class.external_field_configs.each do |config|
+          field = config.field
+          # Check if field is optional (allow_blank or no presence validation)
+          is_optional = _field_is_optional?(config)
+
+          # If method exists, call it (user-defined methods override auto-generated ones)
+          # The auto-generated method for exposed-only fields returns nil (field not in provided_data)
+          next unless respond_to?(field, true)
+
+          value = send(field)
+          # If it returns nil and it's an exposed-only field with no default,
+          # it's likely the auto-generated method (user methods can also return nil, but
+          # we'll assume it's auto-generated in this case)
+          is_exposed_only = !self.class.internal_field_configs.map(&:field).include?(field)
+          is_not_in_provided = !@__context.provided_data.key?(field)
+
+          # Only expose if we have a value, or if it's nil but there's a default
+          # If it's nil and optional, don't expose - let validation handle it
+          if value.nil? && is_exposed_only && is_not_in_provided && config.default.nil? && !is_optional
+            # This is the auto-generated method returning nil for a required field
+            # Don't expose it - let outbound validation catch the missing exposure
+          else
+            exposures[field] = value unless value.nil? && config.default.nil?
+          end
+          # If method doesn't exist:
+          # - If optional, skip it - validation will handle it
+          # - If not optional and no default, skip it - let outbound validation catch it
+          # - If there's a default, skip it - the default will be applied later
+        end
+
+        expose(**exposures) if exposures.any?
+      end
+
+      private
+
+      def _field_is_optional?(config)
+        validations = config.validations
+        # Field is optional if:
+        # 1. It doesn't have presence: true validation (presence is the default for non-optional fields)
+        # 2. Any validator has allow_blank: true
+        return true unless validations.key?(:presence) && validations[:presence] == true
+
+        # Check if any validator has allow_blank: true
+        validations.values.any? { |v| v.is_a?(Hash) && v[:allow_blank] == true }
+      end
+    end
+  end
+end

data/lib/axn/core/flow/exception_execution.rb

@@ -10,6 +10,7 @@ module Axn
 
             def _trigger_on_exception(exception)
               # Call any handlers registered on *this specific action* class
+              # (handlers can call context_for_logging themselves if needed)
               self.class._dispatch_callbacks(:exception, action: self, exception:)
 
               # Call any global handlers
@@ -32,6 +33,10 @@ module Axn
 
           def _with_exception_handling
             yield
+          rescue Axn::Internal::EarlyCompletion
+            # Early completion is not an error - it's a control flow mechanism
+            # It should propagate through to be handled by the result builder
+            raise
           rescue StandardError => e
             @__context.__record_exception(e)
 

data/lib/axn/core/flow/handlers/descriptors/message_descriptor.rb

@@ -37,13 +37,25 @@ module Axn
             def self._build_rule_for_from_condition(from_class)
               return nil unless from_class
 
-              if from_class.is_a?(String)
-                lambda { |exception:, **|
-                  exception.is_a?(Axn::Failure) && exception.source&.class&.name == from_class
-                }
-              else
-                ->(exception:, **) { exception.is_a?(Axn::Failure) && exception.source.is_a?(from_class) }
-              end
+              # Special case: `from: true` means "from any child action"
+              return ->(exception:, **) { exception.is_a?(Axn::Failure) && exception.source } if from_class == true
+
+              from_classes = Array(from_class)
+              lambda { |exception:, **|
+                return false unless exception.is_a?(Axn::Failure) && exception.source
+
+                source = exception.source
+                from_classes.any? do |cls|
+                  if cls.is_a?(String)
+                    # rubocop:disable Style/ClassEqualityComparison
+                    # We're comparing class name strings, not classes themselves
+                    source.class.name == cls
+                    # rubocop:enable Style/ClassEqualityComparison
+                  else
+                    source.is_a?(cls)
+                  end
+                end
+              }
             end
           end
         end

data/lib/axn/core/flow/handlers/invoker.rb

@@ -17,22 +17,6 @@ module Axn
             Axn::Internal::Logging.piping_error(operation, action:, exception: e)
           end
 
-          # Shared introspection helpers
-          def accepts_exception_keyword?(callable_or_method)
-            return false unless callable_or_method.respond_to?(:parameters)
-
-            params = callable_or_method.parameters
-            params.any? { |type, name| %i[keyreq key].include?(type) && name == :exception } ||
-              params.any? { |type, _| type == :keyrest }
-          end
-
-          def accepts_positional_exception?(callable_or_method)
-            return false unless callable_or_method.respond_to?(:arity)
-
-            arity = callable_or_method.arity
-            arity == 1 || arity.negative?
-          end
-
           private
 
           def symbol?(value) = value.is_a?(Symbol)
@@ -46,23 +30,13 @@ module Axn
             end
 
             method = action.method(symbol)
-            if exception && accepts_exception_keyword?(method)
-              action.send(symbol, exception:)
-            elsif exception && accepts_positional_exception?(method)
-              action.send(symbol, exception)
-            else
-              action.send(symbol)
-            end
+            filtered_args, filtered_kwargs = Axn::Util::Callable.only_requested_params_for_exception(method, exception)
+            action.send(symbol, *filtered_args, **filtered_kwargs)
           end
 
           def call_callable_handler(action:, callable:, exception: nil)
-            if exception && accepts_exception_keyword?(callable)
-              action.instance_exec(exception:, &callable)
-            elsif exception && accepts_positional_exception?(callable)
-              action.instance_exec(exception, &callable)
-            else
-              action.instance_exec(&callable)
-            end
+            filtered_args, filtered_kwargs = Axn::Util::Callable.only_requested_params_for_exception(callable, exception)
+            action.instance_exec(*filtered_args, **filtered_kwargs, &callable)
           end
 
           def literal_value(value) = value

data/lib/axn/core/flow/handlers/matcher.rb

@@ -36,25 +36,15 @@ module Axn
           def exception_class? = @rule.is_a?(Class) && @rule <= Exception
 
           def apply_callable(action:, exception:)
-            if exception && Invoker.accepts_exception_keyword?(@rule)
-              !!action.instance_exec(exception:, &@rule)
-            elsif exception && Invoker.accepts_positional_exception?(@rule)
-              !!action.instance_exec(exception, &@rule)
-            else
-              !!action.instance_exec(&@rule)
-            end
+            filtered_args, filtered_kwargs = Axn::Util::Callable.only_requested_params_for_exception(@rule, exception)
+            !!action.instance_exec(*filtered_args, **filtered_kwargs, &@rule)
           end
 
           def apply_symbol(action:, exception:)
             if action.respond_to?(@rule)
               method = action.method(@rule)
-              if exception && Invoker.accepts_exception_keyword?(method)
-                !!action.public_send(@rule, exception:)
-              elsif exception && Invoker.accepts_positional_exception?(method)
-                !!action.public_send(@rule, exception)
-              else
-                !!action.public_send(@rule)
-              end
+              filtered_args, filtered_kwargs = Axn::Util::Callable.only_requested_params_for_exception(method, exception)
+              !!action.public_send(@rule, *filtered_args, **filtered_kwargs)
             else
               begin
                 klass = Object.const_get(@rule.to_s)

data/lib/axn/core/flow/messages.rb

@@ -24,7 +24,7 @@ module Axn
             raise Axn::UnsupportedArgument, "calling #{kind} with both :if and :unless" if kwargs.key?(:if) && kwargs.key?(:unless)
             raise Axn::UnsupportedArgument, "Combining from: with if: or unless:" if kwargs.key?(:from) && (kwargs.key?(:if) || kwargs.key?(:unless))
             raise ArgumentError, "Provide either a message or a block, not both" if message && block_given?
-            raise ArgumentError, "Provide a message, block, or prefix" unless message || block_given? || kwargs[:prefix]
+            raise ArgumentError, "Provide a message, block, or prefix" unless message || block_given? || kwargs[:prefix] || kwargs[:from]
             raise ArgumentError, "from: only applies to error messages" if kwargs.key?(:from) && kind != :error
 
             # If message is already a descriptor, use it directly

data/lib/axn/core/hooks.rb

@@ -128,6 +128,7 @@ module Axn
         yield
       rescue Axn::Internal::EarlyCompletion => e
         @__context.__record_early_completion(e.message)
+        raise e
       end
     end
   end

data/lib/axn/core/logging.rb

@@ -17,20 +17,31 @@ module Axn
       module ClassMethods
         def log_level = Axn.config.log_level
 
-        def log(message, level: log_level, before: nil, after: nil)
-          msg = [_log_prefix, message].compact_blank.join(" ")
+        # @param message [String] The message to log
+        # @param level [Symbol] The log level (default: log_level)
+        # @param before [String, nil] Text to prepend to the message
+        # @param after [String, nil] Text to append to the message
+        # @param prefix [String, nil] Override the default prefix (useful for class-level logging)
+        def log(message, level: log_level, before: nil, after: nil, prefix: nil)
+          resolved_prefix = prefix.nil? ? _log_prefix : prefix
+          msg = [resolved_prefix, message].compact_blank.join(" ")
           msg = [before, msg, after].compact_blank.join if before || after
 
           Axn.config.logger.send(level, msg)
         end
 
         LEVELS.each do |level|
-          define_method(level) do |message, before: nil, after: nil|
-            log(message, level:, before:, after:)
+          define_method(level) do |message, before: nil, after: nil, prefix: nil|
+            log(message, level:, before:, after:, prefix:)
           end
         end
 
-        def _log_prefix = "[#{name.presence || "Anonymous Class"}]"
+        def _log_prefix
+          names = NestingTracking._current_axn_stack.map do |axn|
+            axn.class.name.presence || "Anonymous Class"
+          end
+          "[#{names.join(' > ')}]"
+        end
       end
     end
   end