evilution 0.25.0 → 0.27.0

data/lib/evilution/reporter/cli/trailer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../cli"
+require_relative "line_formatters/truncation_notice"
+require_relative "line_formatters/result_line"
+require_relative "line_formatters/feedback_footer"
+
+class Evilution::Reporter::CLI::Trailer
+  DEFAULT_LINES = [
+    Evilution::Reporter::CLI::LineFormatters::TruncationNotice.new,
+    Evilution::Reporter::CLI::LineFormatters::ResultLine.new,
+    Evilution::Reporter::CLI::LineFormatters::FeedbackFooter.new
+  ].freeze
+
+  def initialize(lines: DEFAULT_LINES)
+    @lines = lines
+  end
+
+  def call(summary)
+    @lines.filter_map { |line| line.format(summary) }
+  end
+end

data/lib/evilution/reporter/cli.rb

@@ -5,172 +5,89 @@ require_relative "../reporter"
 class Evilution::Reporter::CLI
   SEPARATOR = "=" * 44
 
-  def call(summary)
-    lines = []
-    append_metrics(lines, summary)
-    append_sections(lines, summary)
-    lines << ""
-    lines << "[TRUNCATED] Stopped early due to --fail-fast" if summary.truncated?
-    lines << result_line(summary)
-    lines.join("\n")
+  def initialize(
+    header: LineFormatters::Header.new,
+    metrics_block: MetricsBlock.new,
+    section_renderer: SectionRenderer.new,
+    sections: DEFAULT_SECTIONS,
+    trailer: Trailer.new
+  )
+    @header = header
+    @metrics_block = metrics_block
+    @section_renderer = section_renderer
+    @sections = sections
+    @trailer = trailer
   end
 
-  private
-
-  def append_metrics(lines, summary)
-    lines << header
+  def call(summary)
+    lines = []
+    lines << @header.format(summary)
     lines << SEPARATOR
     lines << ""
-    lines << mutations_line(summary)
-    lines << score_line(summary)
-    lines << duration_line(summary)
-    lines << efficiency_line(summary) if summary.duration.positive?
-    peak = summary.peak_memory_mb
-    lines << peak_memory_line(peak) if peak
-  end
-
-  def append_sections(lines, summary)
-    append_survived(lines, summary)
-    append_neutral(lines, summary)
-    append_equivalent(lines, summary)
-    append_unresolved(lines, summary)
-    append_unparseable(lines, summary)
-    append_errors(lines, summary)
-    append_disabled(lines, summary)
-  end
-
-  def append_survived(lines, summary)
-    gaps = summary.coverage_gaps
-    return unless gaps.any?
-
-    lines << ""
-    lines << "Survived mutations (#{gaps.length} coverage gap#{"s" unless gaps.length == 1}):"
-    gaps.each { |gap| lines << format_coverage_gap(gap) }
-  end
-
-  def append_neutral(lines, summary)
-    return unless summary.neutral_results.any?
-
-    lines << ""
-    lines << "Neutral mutations (test already failing):"
-    summary.neutral_results.each { |result| lines << format_neutral(result) }
-  end
-
-  def append_equivalent(lines, summary)
-    return unless summary.equivalent_results.any?
-
-    lines << ""
-    lines << "Equivalent mutations (provably identical behavior):"
-    summary.equivalent_results.each { |result| lines << format_neutral(result) }
-  end
-
-  def append_unresolved(lines, summary)
-    return unless summary.unresolved_results.any?
-
-    lines << ""
-    lines << "Unresolved mutations (no test file resolved):"
-    summary.unresolved_results.each { |result| lines << format_neutral(result) }
-  end
-
-  def append_unparseable(lines, summary)
-    return unless summary.unparseable_results.any?
-
-    lines << ""
-    lines << "Unparseable mutations (mutated source did not parse):"
-    summary.unparseable_results.each { |result| lines << format_neutral(result) }
-  end
-
-  def append_errors(lines, summary)
-    errored = summary.results.select(&:error?)
-    return if errored.empty?
-
+    lines.concat(@metrics_block.call(summary))
+    @sections.each { |section| lines.concat(@section_renderer.call(section, summary)) }
     lines << ""
-    lines << "Errored mutations:"
-    errored.each { |result| lines << format_error(result) }
-  end
-
-  def format_error(result)
-    mutation = result.mutation
-    header = "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
-    return header unless result.error_message
-
-    indented = result.error_message.lines.map { |line| "    #{line.chomp}" }.join("\n")
-    "#{header}\n#{indented}"
-  end
-
-  def append_disabled(lines, summary)
-    return unless summary.disabled_mutations.any?
-
-    lines << ""
-    lines << "Disabled mutations (skipped by # evilution:disable):"
-    summary.disabled_mutations.each { |mutation| lines << format_disabled(mutation) }
-  end
-
-  def header
-    "Evilution v#{Evilution::VERSION} — Mutation Testing Results"
-  end
-
-  def mutations_line(summary)
-    parts = "Mutations: #{summary.total} total, #{summary.killed} killed, " \
-            "#{summary.survived} survived, #{summary.timed_out} timed out"
-    parts += ", #{summary.neutral} neutral" if summary.neutral.positive?
-    parts += ", #{summary.equivalent} equivalent" if summary.equivalent.positive?
-    parts += ", #{summary.unresolved} unresolved" if summary.unresolved.positive?
-    parts += ", #{summary.unparseable} unparseable" if summary.unparseable.positive?
-    parts += ", #{summary.skipped} skipped" if summary.skipped.positive?
-    parts
-  end
-
-  def score_line(summary)
-    score_pct = format_pct(summary.score)
-    "Score: #{score_pct} (#{summary.killed}/#{summary.score_denominator})"
-  end
-
-  def duration_line(summary)
-    "Duration: #{format("%.2f", summary.duration)}s"
-  end
-
-  def efficiency_line(summary)
-    pct = format("%.2f%%", summary.efficiency * 100)
-    rate = format("%.2f", summary.mutations_per_second)
-    "Efficiency: #{pct} killtime, #{rate} mutations/s"
-  end
-
-  def format_coverage_gap(gap)
-    location = "#{gap.file_path}:#{gap.line}"
-    header = if gap.single?
-               "  #{gap.primary_operator}: #{location} (#{gap.subject_name})"
-             else
-               operators = gap.operator_names.join(", ")
-               "  #{location} (#{gap.subject_name}) [#{gap.count} mutations: #{operators}]"
-             end
-    body = gap.mutation_results.first.mutation.unified_diff || gap.primary_diff
-    indented = body.split("\n").map { |l| "    #{l}" }.join("\n")
-    "#{header}\n#{indented}"
-  end
-
-  def format_neutral(result)
-    mutation = result.mutation
-    "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
-  end
-
-  def format_disabled(mutation)
-    "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
-  end
-
-  def result_line(summary)
-    min_score = 0.8
-    pass_fail = summary.success?(min_score: min_score) ? "PASS" : "FAIL"
-    score_pct = format_pct(summary.score)
-    threshold_pct = format_pct(min_score)
-    "Result: #{pass_fail} (score #{score_pct} #{pass_fail == "PASS" ? ">=" : "<"} #{threshold_pct})"
-  end
-
-  def peak_memory_line(peak_mb)
-    format("Peak memory: %<mb>.1f MB", mb: peak_mb)
-  end
-
-  def format_pct(value)
-    format("%.2f%%", value * 100)
+    lines.concat(@trailer.call(summary))
+    lines.join("\n")
   end
 end
+
+require_relative "cli/pct"
+require_relative "cli/section"
+require_relative "cli/section_renderer"
+require_relative "cli/line_formatters/header"
+require_relative "cli/line_formatters/mutations"
+require_relative "cli/line_formatters/score"
+require_relative "cli/line_formatters/duration"
+require_relative "cli/line_formatters/efficiency"
+require_relative "cli/line_formatters/peak_memory"
+require_relative "cli/line_formatters/truncation_notice"
+require_relative "cli/line_formatters/result_line"
+require_relative "cli/line_formatters/feedback_footer"
+require_relative "cli/item_formatters/coverage_gap"
+require_relative "cli/item_formatters/result_location"
+require_relative "cli/item_formatters/error"
+require_relative "cli/item_formatters/disabled"
+require_relative "cli/metrics_block"
+require_relative "cli/trailer"
+
+Evilution::Reporter::CLI.const_set(
+  :DEFAULT_SECTIONS,
+  [
+    Evilution::Reporter::CLI::Section.new(
+      title: ->(gaps) { "Survived mutations (#{gaps.length} coverage gap#{"s" unless gaps.length == 1}):" },
+      fetcher: lambda(&:coverage_gaps),
+      formatter: Evilution::Reporter::CLI::ItemFormatters::CoverageGap.new
+    ),
+    Evilution::Reporter::CLI::Section.new(
+      title: "Neutral mutations (test already failing):",
+      fetcher: lambda(&:neutral_results),
+      formatter: Evilution::Reporter::CLI::ItemFormatters::ResultLocation.new
+    ),
+    Evilution::Reporter::CLI::Section.new(
+      title: "Equivalent mutations (provably identical behavior):",
+      fetcher: lambda(&:equivalent_results),
+      formatter: Evilution::Reporter::CLI::ItemFormatters::ResultLocation.new
+    ),
+    Evilution::Reporter::CLI::Section.new(
+      title: "Unresolved mutations (no test file resolved):",
+      fetcher: lambda(&:unresolved_results),
+      formatter: Evilution::Reporter::CLI::ItemFormatters::ResultLocation.new
+    ),
+    Evilution::Reporter::CLI::Section.new(
+      title: "Unparseable mutations (mutated source did not parse):",
+      fetcher: lambda(&:unparseable_results),
+      formatter: Evilution::Reporter::CLI::ItemFormatters::ResultLocation.new
+    ),
+    Evilution::Reporter::CLI::Section.new(
+      title: "Errored mutations:",
+      fetcher: ->(s) { s.results.select(&:error?) },
+      formatter: Evilution::Reporter::CLI::ItemFormatters::Error.new
+    ),
+    Evilution::Reporter::CLI::Section.new(
+      title: "Disabled mutations (skipped by # evilution:disable):",
+      fetcher: lambda(&:disabled_mutations),
+      formatter: Evilution::Reporter::CLI::ItemFormatters::Disabled.new
+    )
+  ].freeze
+)

data/lib/evilution/runner/isolation_resolver.rb

@@ -9,6 +9,7 @@ class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disabl
 class Evilution::Runner::IsolationResolver
   PRELOAD_CANDIDATES = [
     File.join("spec", "rails_helper.rb"),
+    File.join("spec", "spec_helper.rb"),
     File.join("test", "test_helper.rb")
   ].freeze
 
@@ -30,13 +31,15 @@ class Evilution::Runner::IsolationResolver
 
   def perform_preload
     return if config.preload == false
-    return unless resolve_isolation == :fork
+    return unless should_preload?
 
     path = resolve_preload_path
     return unless path
 
     prepare_load_path_for_preload
     require File.expand_path(path)
+  rescue Evilution::ConfigError
+    raise
   rescue ScriptError, StandardError => e
     raise Evilution::ConfigError.new(
       "failed to preload #{path.inspect}: #{e.class}: #{e.message}",
@@ -48,6 +51,17 @@ class Evilution::Runner::IsolationResolver
 
   attr_reader :config, :hooks
 
+  # Under :fork, allow preloading — caller resolves whether a path exists (an
+  # explicit --preload / preload: value, or an auto-detected rails_helper) and
+  # bails early when none does. Under :in_process, only allow preloading when
+  # the user explicitly asked via --preload or preload: in YAML — don't
+  # auto-load spec/rails_helper.rb for a user who opted out of fork.
+  def should_preload?
+    return true if resolve_isolation == :fork
+
+    config.preload.is_a?(String)
+  end
+
   def target_files
     @target_files ||= @target_files_callback.call
   end
@@ -112,7 +126,11 @@ class Evilution::Runner::IsolationResolver
       abs = File.join(root, rel)
       return abs if File.file?(abs)
     end
-    nil
+
+    raise Evilution::ConfigError,
+          "Preload file not found. Tried: [#{PRELOAD_CANDIDATES.join(", ")}]. " \
+          "Pass --preload <file> or set preload: in .evilution.yml. " \
+          "Use --no-preload (or preload: false) to disable preloading entirely."
   end
 
   # When the user explicitly requests InProcess on a Rails project, warn once

data/lib/evilution/runner/mutation_executor/mutation_runner.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../../result/mutation_result"
+
+class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
+class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
+
+class Evilution::Runner::MutationExecutor::MutationRunner
+  def initialize(config:, cache:, isolator:)
+    @config = config
+    @cache = cache
+    @isolator = isolator
+  end
+
+  def call(mutation, integration:)
+    return unparseable_result(mutation) if mutation.unparseable?
+
+    cached = @cache.fetch(mutation)
+    return cached if cached
+
+    test_command = ->(m) { integration.call(m) }
+    result = @isolator.call(mutation: mutation, test_command: test_command, timeout: @config.timeout)
+    @cache.store(mutation, result)
+    result
+  end
+
+  private
+
+  def unparseable_result(mutation)
+    Evilution::Result::MutationResult.new(mutation: mutation, status: :unparseable)
+  end
+end

data/lib/evilution/runner/mutation_executor/neutralization_pipeline.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
+class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
+
+class Evilution::Runner::MutationExecutor::NeutralizationPipeline
+  def initialize(neutralizers)
+    @neutralizers = neutralizers
+  end
+
+  def call(result, **ctx)
+    @neutralizers.reduce(result) do |acc, nz|
+      ctx.empty? ? nz.call(acc) : nz.call(acc, **ctx)
+    end
+  end
+end

data/lib/evilution/runner/mutation_executor/neutralizer/baseline_failed.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../../../result/mutation_result"
+
+class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
+class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
+module Evilution::Runner::MutationExecutor::Neutralizer; end unless defined?(Evilution::Runner::MutationExecutor::Neutralizer)
+
+class Evilution::Runner::MutationExecutor::Neutralizer::BaselineFailed
+  def initialize(config:, spec_resolver:, fallback_dir:)
+    @config = config
+    @spec_resolver = spec_resolver
+    @fallback_dir = fallback_dir
+  end
+
+  def call(result, baseline_result:)
+    return result unless result.survived? && baseline_result && baseline_result.failed?
+
+    if @config.spec_files.any?
+      should_neutralize = true
+    else
+      spec_file = @spec_resolver.call(result.mutation.file_path) || @fallback_dir
+      should_neutralize = baseline_result.failed_spec_files.include?(spec_file)
+    end
+    return result unless should_neutralize
+
+    neutralize(result)
+  end
+
+  private
+
+  def neutralize(result)
+    Evilution::Result::MutationResult.new(
+      mutation: result.mutation,
+      status: :neutral,
+      duration: result.duration,
+      test_command: result.test_command,
+      child_rss_kb: result.child_rss_kb,
+      memory_delta_kb: result.memory_delta_kb,
+      parent_rss_kb: result.parent_rss_kb,
+      error_message: result.error_message,
+      error_class: result.error_class,
+      error_backtrace: result.error_backtrace
+    )
+  end
+end

data/lib/evilution/runner/mutation_executor/neutralizer/infra_error.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../../../result/mutation_result"
+
+class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
+class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
+module Evilution::Runner::MutationExecutor::Neutralizer; end unless defined?(Evilution::Runner::MutationExecutor::Neutralizer)
+
+# Reclassify results as :neutral when the failure was caused by test
+# infrastructure rather than by the mutation. Two independent paths:
+#
+# 1) :error from a missing require / spec_helper / rails_helper / spec/support
+#    initialization — detected by error_class ∈ INFRA_ERROR_CLASSES and
+#    first backtrace frame matching INFRA_BACKTRACE_PATHS. Origin-only match
+#    (not `any?`): Ruby backtraces typically carry spec_helper frames below
+#    mutation-caused errors, so matching any frame would misclassify real
+#    mutation NameError/LoadError as :neutral.
+#
+# 2) :killed from a CrashDetector test_crashed whose sole crash class is in
+#    INFRA_CRASH_CLASSES (ActiveRecord::StatementTimeout, Timeout::Error,
+#    etc.). These surface under parallel workers sharing a DB file or on a
+#    slow CI; fork.rb initially reports them as :killed, and without this
+#    demotion the kill count inflates with infra noise. No backtrace check:
+#    the single-class signal from CrashDetector already rules out mixed
+#    mutation-caused failures. See EV-toid / GH #814.
+class Evilution::Runner::MutationExecutor::Neutralizer::InfraError
+  INFRA_ERROR_CLASSES = %w[LoadError NameError].freeze
+  INFRA_BACKTRACE_PATHS = %r{(?:^|/)(?:spec_helper\.rb|rails_helper\.rb|spec/support/)}
+  INFRA_CRASH_CLASSES = %w[
+    Timeout::Error
+    ActiveRecord::StatementTimeout
+    ActiveRecord::Deadlocked
+    ActiveRecord::ConnectionTimeoutError
+    ActiveRecord::LockWaitTimeout
+    SQLite3::BusyException
+  ].freeze
+  private_constant :INFRA_ERROR_CLASSES, :INFRA_BACKTRACE_PATHS, :INFRA_CRASH_CLASSES
+
+  def call(result, **_ctx)
+    return neutralize(result) if infra_crash?(result)
+    return result unless result.error?
+    return result unless INFRA_ERROR_CLASSES.include?(result.error_class)
+    return result unless infra_origin?(result.error_backtrace)
+
+    neutralize(result)
+  end
+
+  private
+
+  def infra_crash?(result)
+    result.killed? && INFRA_CRASH_CLASSES.include?(result.error_class)
+  end
+
+  def infra_origin?(backtrace)
+    frames = Array(backtrace)
+    return false if frames.empty?
+
+    frames.first =~ INFRA_BACKTRACE_PATHS ? true : false
+  end
+
+  def neutralize(result)
+    Evilution::Result::MutationResult.new(
+      mutation: result.mutation,
+      status: :neutral,
+      duration: result.duration,
+      test_command: result.test_command,
+      child_rss_kb: result.child_rss_kb,
+      memory_delta_kb: result.memory_delta_kb,
+      parent_rss_kb: result.parent_rss_kb,
+      error_message: result.error_message,
+      error_class: result.error_class,
+      error_backtrace: result.error_backtrace
+    )
+  end
+end

data/lib/evilution/runner/mutation_executor/result_cache.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../../result/mutation_result"
+
+class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
+class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
+
+class Evilution::Runner::MutationExecutor::ResultCache
+  CACHEABLE_STATUSES = %i[killed timeout].freeze
+  private_constant :CACHEABLE_STATUSES
+
+  def initialize(backend)
+    @backend = backend
+  end
+
+  def fetch(mutation)
+    return nil unless @backend
+
+    data = @backend.fetch(mutation)
+    return nil unless data
+    return nil unless CACHEABLE_STATUSES.include?(data[:status])
+
+    Evilution::Result::MutationResult.new(
+      mutation: mutation,
+      status: data[:status],
+      duration: data[:duration],
+      killing_test: data[:killing_test],
+      test_command: data[:test_command]
+    )
+  end
+
+  def store(mutation, result)
+    return unless @backend
+    return unless result.killed? || result.timeout?
+
+    @backend.store(mutation,
+                   status: result.status,
+                   duration: result.duration,
+                   killing_test: result.killing_test,
+                   test_command: result.test_command)
+  end
+
+  def partition(batch, packer:)
+    uncached_indices = []
+    cached_results = {}
+
+    batch.each_with_index do |mutation, i|
+      if mutation.unparseable?
+        cached_results[i] = packer.compact(unparseable_result(mutation))
+        next
+      end
+
+      cached = fetch(mutation)
+      if cached
+        cached_results[i] = packer.compact(cached)
+      else
+        uncached_indices << i
+      end
+    end
+
+    [uncached_indices, cached_results]
+  end
+
+  private
+
+  def unparseable_result(mutation)
+    Evilution::Result::MutationResult.new(mutation: mutation, status: :unparseable)
+  end
+end

data/lib/evilution/runner/mutation_executor/result_notifier.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../../reporter/progress_bar"
+
+class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
+class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
+
+class Evilution::Runner::MutationExecutor::ResultNotifier
+  def initialize(config, diagnostics:, on_result:)
+    @config = config
+    @diagnostics = diagnostics
+    @on_result = on_result
+    @survived_count = 0
+    @progress_bar = nil
+  end
+
+  attr_reader :survived_count
+
+  def start(total)
+    @survived_count = 0
+    @progress_bar = build_progress_bar(total)
+  end
+
+  def notify(result, index)
+    @on_result.call(result) if @on_result
+    @progress_bar.tick(status: result.status) if @progress_bar
+    @diagnostics.log_progress(index, result.status)
+    @diagnostics.log_mutation_diagnostics(result)
+    @survived_count += 1 if result.survived?
+    truncate? ? :truncate : :continue
+  end
+
+  def finish
+    @progress_bar.finish if @progress_bar
+  end
+
+  private
+
+  def truncate?
+    @config.fail_fast? && @survived_count >= @config.fail_fast
+  end
+
+  def build_progress_bar(total)
+    return nil if !@config.progress? || @config.quiet || @config.verbose || !@config.text? || !$stderr.tty?
+
+    Evilution::Reporter::ProgressBar.new(total: total, output: $stderr)
+  end
+end

data/lib/evilution/runner/mutation_executor/result_packer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../../result/mutation_result"
+
+class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
+class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
+
+class Evilution::Runner::MutationExecutor::ResultPacker
+  def compact(result)
+    {
+      status: result.status,
+      duration: result.duration,
+      killing_test: result.killing_test,
+      test_command: result.test_command,
+      child_rss_kb: result.child_rss_kb,
+      memory_delta_kb: result.memory_delta_kb,
+      parent_rss_kb: result.parent_rss_kb,
+      error_message: result.error_message,
+      error_class: result.error_class,
+      error_backtrace: result.error_backtrace
+    }
+  end
+
+  def rebuild(mutation, data)
+    Evilution::Result::MutationResult.new(
+      mutation: mutation,
+      status: data[:status],
+      duration: data[:duration],
+      killing_test: data[:killing_test],
+      test_command: data[:test_command],
+      child_rss_kb: data[:child_rss_kb],
+      memory_delta_kb: data[:memory_delta_kb],
+      parent_rss_kb: data[:parent_rss_kb],
+      error_message: data[:error_message],
+      error_class: data[:error_class],
+      error_backtrace: data[:error_backtrace]
+    )
+  end
+end