rails_benchmark_suite 0.3.0 → 0.3.1

data/lib/rails_benchmark_suite/reporters/html_reporter.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "erb"
+require "json"
+require "fileutils"
+
+module RailsBenchmarkSuite
+  module Reporters
+    class HtmlReporter
+      def initialize(payload)
+        @payload = payload
+      end
+
+      def generate
+        template_path = File.expand_path("../templates/report.html.erb", __dir__)
+        template = File.read(template_path)
+        
+        # Prepare data for JS injection (Flatten complex objects to simple Hash)
+        chart_data = {
+          labels: @payload[:results].map { |r| r[:name] },
+          data_1t: [],
+          data_mt: []
+        }
+
+        @payload[:results].each do |res|
+          entry_1t = res[:report].entries.find { |e| e.label.include?("(1 thread)") }
+          entry_mt = res[:report].entries.find { |e| e.label.match?(/\(\d+ threads\)/) }
+          
+          chart_data[:data_1t] << (entry_1t ? entry_1t.ips : 0)
+          chart_data[:data_mt] << (entry_mt ? entry_mt.ips : 0)
+        end
+
+        @chart_payload = chart_data.to_json
+        
+        # Render
+        html = ERB.new(template).result(binding)
+        
+        # Output file
+        dir = Dir.exist?("tmp") ? "tmp" : "."
+        file_path = File.join(dir, "rails_benchmark_report.html")
+        File.write(file_path, html)
+        
+        puts "\n"
+        puts "✅ HTML Report Generated!"
+        puts "📂 Location: #{File.expand_path(file_path)}"
+        puts "👉 View (Local):  open '#{file_path}'"
+        puts "👉 View (Remote): scp user@server:#{File.expand_path(file_path)} ."
+        puts "\n"
+      end
+    end
+  end
+end

data/lib/rails_benchmark_suite/runner.rb

@@ -1,23 +1,66 @@
-# frozen_string_literal: true
+require_relative "database_manager"
+require_relative "workload_runner"
+require_relative "reporter"
+require_relative "schema"
+require_relative "../dummy/app/models/benchmark_user"
+require_relative "../dummy/app/models/benchmark_post"
+require_relative "../dummy/app/models/benchmark_job"
 
 module RailsBenchmarkSuite
   class Runner
-    def initialize(workloads, json: false)
-      @workloads = workloads
-      @json_output = json
+    # Registry for workloads
+    @workloads = []
+
+    def self.register_workload(name, weight: 1.0, &block)
+      @workloads << { name: name, weight: weight, block: block }
+    end
+
+    def initialize(config)
+      @config = config
     end
 
     def run
-      DatabaseManager.new.setup
-      Formatter.header(Reporter.system_info) unless @json_output
+      # Load workloads dynamically if not already loaded (idempotent)
+      if Runner.instance_variable_get(:@workloads).empty?
+        Dir[File.join(__dir__, "workloads", "*.rb")].each { |f| require f }
+      end
+
+      # 1. Setup Database
+      DatabaseManager.new.setup(use_local_db: @config.db)
       
-      # Delegate ALL math and execution to the WorkloadRunner
-      payload = WorkloadRunner.new(@workloads, show_progress: !@json_output).execute
+      # 2. Display Header
+      header_info = Reporter.system_info.merge(
+        threads: @config.threads,
+        db_mode: @config.db_mode
+      )
+      Reporter.header(header_info) unless @config.json
       
-      if @json_output
-        Formatter.as_json(payload)
+      # 3. Execute Workloads
+      # Passing config values as options to WorkloadRunner for compatibility
+      # Ideally we'd pass the config object but WorkloadRunner expects a hash currently
+      # We will refactor WorkloadRunner to accept config later or wrap it here
+      runner_options = {
+        threads: @config.threads,
+        profile: @config.profile
+      }
+      
+      payload = WorkloadRunner.new(
+        Runner.instance_variable_get(:@workloads), 
+        options: runner_options,
+        show_progress: !@config.json
+      ).execute
+      
+      # 4. Report Results
+      if @config.json
+        Reporter.as_json(payload)
       else
-        Formatter.summary_with_insights(payload)
+        Reporter.render(payload)
+      end
+
+      # 5. HTML Report Generation
+      if @config.html
+        require_relative "reporters/html_reporter"
+        Reporters::HtmlReporter.new(payload).generate
       end
     end
   end

data/lib/rails_benchmark_suite/schema.rb

@@ -6,16 +6,16 @@ module RailsBenchmarkSuite
   module Schema
     def self.load
       ActiveRecord::Schema.define do
-        # Users
-        create_table :users, force: true do |t|
+        # BenchmarkUsers
+        create_table :benchmark_users, force: true do |t|
           t.string :name
           t.string :email
           t.timestamps
         end
 
-        # Posts
-        create_table :posts, force: true do |t|
-          t.references :user
+        # BenchmarkPosts
+        create_table :benchmark_posts, force: true do |t|
+          t.references :benchmark_user, foreign_key: { to_table: :benchmark_users }
           t.string :title
           t.text :body
           t.integer :views, default: 0

data/lib/rails_benchmark_suite/templates/report.html.erb

@@ -0,0 +1,187 @@
+<!DOCTYPE html>
+<html lang="en" data-bs-theme="dark">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Rails Benchmark Suite Report</title>
+    <!-- Bootstrap 5 CDN -->
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
+    <!-- Chart.js 4 CDN -->
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    
+    <style>
+        body { background-color: #121212; color: #e0e0e0; font-family: 'Segoe UI', system-ui, -apple-system, sans-serif; }
+        .card { background-color: #1e1e1e; border: 1px solid #333; }
+        .table-dark { --bs-table-bg: #1e1e1e; --bs-table-striped-bg: #252525; }
+        .efficiency-high { color: #4caf50; font-weight: bold; }
+        .efficiency-med { color: #ffc107; font-weight: bold; }
+        .efficiency-low { color: #f44336; font-weight: bold; }
+        .header-bar { border-bottom: 2px solid #3d3d3d; padding-bottom: 20px; margin-bottom: 30px; }
+    </style>
+</head>
+<body class="container py-5">
+
+    <!-- Header -->
+    <div class="header-bar d-flex justify-content-between align-items-center">
+        <div>
+            <h1 class="display-5 fw-bold text-light">Rails Benchmark Suite</h1>
+            <p class="text-secondary mb-0">v<%= RailsBenchmarkSuite::VERSION %> Report</p>
+        </div>
+        <div class="text-end text-white-50">
+            <div>Ruby <%= RUBY_VERSION %></div>
+            <div><%= @payload[:threads] %> Threads</div>
+            <div><%= Time.now.strftime("%Y-%m-%d %H:%M") %></div>
+        </div>
+    </div>
+
+    <!-- Score Cards -->
+    <div class="row g-4 mb-5">
+        <div class="col-md-6">
+            <div class="card h-100 p-4 text-center">
+                <h3 class="text-secondary">RHI Score</h3>
+                <div class="display-1 fw-bold <%= @payload[:total_score] > 200 ? 'text-primary' : 'text-light' %>">
+                    <%= @payload[:total_score].to_i %>
+                </div>
+                <div class="badge bg-dark border mt-2"><%= @payload[:tier] %> Tier</div>
+            </div>
+        </div>
+        <div class="col-md-6">
+            <div class="card h-100 p-4 text-center">
+                <h3 class="text-secondary">Avg. Efficiency</h3>
+                <% 
+                   total_eff = @payload[:results].sum do |r| 
+                     entry_1t = r[:report].entries.find { |e| e.label.include?("(1 thread)") }
+                     entry_mt = r[:report].entries.find { |e| e.label.match?(/\(\d+ threads\)/) }
+                     next 0 unless entry_1t && entry_mt
+                     (entry_mt.ips / (entry_1t.ips * @payload[:threads])) * 100
+                   end 
+                   avg_eff = total_eff / [@payload[:results].size, 1].max
+                   color_class = avg_eff > 75 ? 'efficiency-high' : (avg_eff > 50 ? 'efficiency-med' : 'efficiency-low')
+                %>
+                <div class="display-1 <%= color_class %>">
+                    <%= avg_eff.round(1) %>%
+                </div>
+                <small class="text-muted">Target: > 80% linear scaling</small>
+            </div>
+        </div>
+    </div>
+
+    <!-- Chart -->
+    <div class="card mb-5">
+        <div class="card-header bg-transparent border-bottom border-secondary">
+            <h5 class="mb-0">Scaling Curve (1T vs MaxT)</h5>
+        </div>
+        <div class="card-body">
+            <canvas id="scalingChart" style="max-height: 400px;"></canvas>
+        </div>
+    </div>
+
+    <!-- Detailed Table -->
+    <div class="card">
+        <div class="card-header bg-transparent border-bottom border-secondary">
+            <h5 class="mb-0">Detailed Metrics</h5>
+        </div>
+        <div class="table-responsive">
+            <table class="table table-dark table-striped table-hover mb-0 align-middle">
+                <thead>
+                    <tr>
+                        <th style="width: 30%">Workload</th>
+                        <th class="text-end">1T IPS</th>
+                        <th class="text-end">MaxT IPS</th>
+                        <th class="text-end">Scaling (x)</th>
+                        <th class="text-end">Efficiency</th>
+                        <th class="text-end">Weight</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <% @payload[:results].each do |res| %>
+                        <% 
+                           entry_1t = res[:report].entries.find { |e| e.label.include?("(1 thread)") }
+                           entry_mt = res[:report].entries.find { |e| e.label.match?(/\(\d+ threads\)/) }
+                           ips_1t = entry_1t ? entry_1t.ips : 0
+                           ips_mt = entry_mt ? entry_mt.ips : 0
+                           
+                           scaling = ips_1t > 0 ? (ips_mt / ips_1t) : 0
+                           efficiency = (ips_1t.to_f > 0) ? (ips_mt.to_f / (ips_1t * @payload[:threads])) * 100 : 0.0
+                           
+                           eff_color = efficiency > 75 ? 'efficiency-high' : (efficiency > 50 ? 'efficiency-med' : 'efficiency-low')
+                           scale_color = scaling >= 1.0 ? 'text-success' : 'text-danger'
+                        %>
+                        <tr>
+                            <td class="fw-medium"><%= res[:name] %></td>
+                            <td class="text-end font-monospace"><%= ips_1t.round(1) %></td>
+                            <td class="text-end font-monospace"><%= ips_mt.round(1) %></td>
+                            <td class="text-end font-monospace <%= scale_color %>"><%= "%.2fx" % scaling %></td>
+                            <td class="text-end font-monospace <%= eff_color %>"><%= efficiency.round(1) %>%</td>
+                            <td class="text-end text-secondary"><%= res[:adjusted_weight].round(2) %></td>
+                        </tr>
+                    <% end %>
+                </tbody>
+            </table>
+        </div>
+    </div>
+
+    <!-- JavaScript Injection -->
+    <script>
+        const CHART_DATA = <%= @chart_payload %>;
+        
+        document.addEventListener('DOMContentLoaded', () => {
+            const ctx = document.getElementById('scalingChart');
+            
+            // Data is already prepared in Ruby
+            const labels = CHART_DATA.labels;
+            const data1T = CHART_DATA.data_1t;
+            const dataMaxT = CHART_DATA.data_mt;
+
+            // Color logic for MaxT bars (Red if bad scaling)
+            const backgroundColors = dataMaxT.map((val, index) => {
+                const ips1 = data1T[index];
+                const scaling = ips1 > 0 ? val / ips1 : 0;
+                return scaling < 0.8 ? 'rgba(239, 83, 80, 0.8)' : 'rgba(156, 39, 176, 0.8)';
+            });
+
+            new Chart(ctx, {
+                type: 'bar',
+                data: {
+                    labels: labels,
+                    datasets: [
+                        {
+                            label: '1-Thread IPS',
+                            data: data1T,
+                            backgroundColor: 'rgba(33, 150, 243, 0.8)',
+                            borderColor: 'rgba(33, 150, 243, 1)',
+                            borderWidth: 1
+                        },
+                        {
+                            label: '<%= @payload[:threads] %>-Thread IPS',
+                            data: dataMaxT,
+                            backgroundColor: backgroundColors,
+                            borderColor: backgroundColors.map(c => c.replace('0.8)', '1)')),
+                            borderWidth: 1
+                        }
+                    ]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    scales: {
+                        y: {
+                            beginAtZero: true,
+                            grid: { color: '#333' },
+                            ticks: { color: '#aaa' },
+                            title: { display: true, text: 'Iterations Per Second (IPS)', color: '#aaa' }
+                        },
+                        x: {
+                            grid: { display: false },
+                            ticks: { color: '#fff' }
+                        }
+                    },
+                    plugins: {
+                        legend: { labels: { color: '#fff' } }
+                    }
+                }
+            });
+        });
+    </script>
+</body>
+</html>

data/lib/rails_benchmark_suite/version.rb

@@ -1,3 +1,3 @@
 module RailsBenchmarkSuite
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/lib/rails_benchmark_suite/workload_runner.rb

@@ -2,6 +2,7 @@
 
 require "benchmark/ips"
 require "get_process_mem"
+require "tty-spinner"
 
 module RailsBenchmarkSuite
   class WorkloadRunner
@@ -14,22 +15,41 @@ module RailsBenchmarkSuite
       "Image Heft" => 0.1
     }.freeze
 
-    def initialize(workloads, show_progress: true)
+    def initialize(workloads, options: {}, show_progress: true)
       @workloads = workloads
+      @options = options
+      @threads = options[:threads] || 4
+      @profile_mode = options[:profile] || false
       @show_progress = show_progress
     end
 
     def execute
+      if @profile_mode && @show_progress
+        puts "\nRunning Scaling Diagnostic (Profile Mode)..."
+      elsif @show_progress
+        puts "\n⏳ Running Benchmarks..."
+      end
+
+      # Initializing MultiSpinner if progress is enabled
+      multi_spinner = TTY::Spinner::Multi.new("[:spinner] Running Workloads", format: :dots) if @show_progress
+
       # Run all workloads and collect results
-      results = @workloads.map.with_index do |w, index|
+      results = @workloads.map do |w|
+        spinner = nil
         if @show_progress
-          Formatter.render_progress(index + 1, @workloads.size, w[:name], "Running")
+          spinner = multi_spinner.register("[:spinner] #{w[:name]}", format: :dots)
+          spinner.auto_spin
         end
         
-        result = run_single_workload(w)
+        result = run_single_workload(w, spinner)
         
-        if @show_progress
-          Formatter.render_progress(index + 1, @workloads.size, w[:name], "Done ✓")
+        if @show_progress && spinner
+          ips_1t = result[:report].entries.find { |e| e.label.include?("(1 thread)") }&.ips || 0
+          ips_mt = result[:report].entries.find { |e| e.label.include?("(#{@threads} threads)") }&.ips || 0
+          
+          # Dynamic Success Message without duplicate name
+          success_msg = " ... #{Reporter.humanize(ips_1t)} IPS (1T) | #{Reporter.humanize(ips_mt)} IPS (#{@threads}T)"
+          spinner.success(success_msg)
         end
         
         result
@@ -46,9 +66,9 @@ module RailsBenchmarkSuite
       # Calculate total score
       total_score = results.sum do |r|
         entries = r[:report].entries
-        entry_4t = entries.find { |e| e.label.include?("(4 threads)") }
-        ips_4t = entry_4t ? entry_4t.ips : 0
-        ips_4t * r[:adjusted_weight]
+        entry_mt = entries.find { |e| e.label.include?("(#{@threads} threads)") }
+        ips_mt = entry_mt ? entry_mt.ips : 0
+        ips_mt * r[:adjusted_weight]
       end
       
       # Determine tier
@@ -64,27 +84,30 @@ module RailsBenchmarkSuite
       {
         results: results,
         total_score: total_score,
-        tier: tier
+        tier: tier,
+        threads: @threads,
+        profile_mode: @profile_mode
       }
     end
 
     private
 
-    def run_single_workload(workload)
+    def run_single_workload(workload, spinner)
       mem_before = GetProcessMem.new.mb
 
       # Run benchmark
       report = Benchmark.ips do |x|
-        x.config(:time => 5, :warmup => 2)
+        # Silence output to allow spinner to own the UI
+        x.config(:time => 5, :warmup => 2, :quiet => true)
         
         # Single Threaded
         x.report("#{workload[:name]} (1 thread)") do
           with_retries { workload[:block].call }
         end
 
-        # Multi Threaded (4 threads)
-        x.report("#{workload[:name]} (4 threads)") do
-          threads = 4.times.map do
+        # Multi Threaded
+        x.report("#{workload[:name]} (#{@threads} threads)") do
+          threads = @threads.times.map do
             Thread.new do
               ActiveRecord::Base.connection_pool.with_connection do
                 with_retries { workload[:block].call }
@@ -94,15 +117,29 @@ module RailsBenchmarkSuite
           threads.each(&:join)
         end
 
-        x.compare!
+        # x.compare! removed to prevent STDOUT pollution
       end
 
       mem_after = GetProcessMem.new.mb
       
+      # Calculate Scaling Efficiency if in profile mode
+      # Efficiency = (Multi Score / (Single Score * Threads)) * 100
+      entries = report.entries
+      entry_1t = entries.find { |e| e.label.include?("(1 thread)") }
+      entry_mt = entries.find { |e| e.label.include?("(#{@threads} threads)") }
+      
+      efficiency = 0.0
+      if entry_1t && entry_mt && entry_1t.ips > 0
+        single_score = entry_1t.ips
+        multi_score = entry_mt.ips
+        efficiency = (multi_score / (single_score * @threads)) * 100
+      end
+
       {
         name: workload[:name],
         report: report,
-        memory_delta_mb: mem_after - mem_before
+        memory_delta_mb: mem_after - mem_before,
+        efficiency: efficiency
       }
     end
 

data/lib/rails_benchmark_suite/workloads/active_record_workload.rb

@@ -3,12 +3,12 @@
 require "active_record"
 
 # Benchmark Workload
-RailsBenchmarkSuite.register_workload("Active Record Heft", weight: 0.4) do
+RailsBenchmarkSuite::Runner.register_workload("Active Record Heft", weight: 0.4) do
   # Workload: Create User with Posts, Join Query, Update
   # Use transaction rollback to keep the DB clean and avoid costly destroy callbacks
   ActiveRecord::Base.transaction do
     # 1. Create - with unique email per thread
-    user = RailsBenchmarkSuite::Models::User.create!(
+    user = RailsBenchmarkSuite::Dummy::BenchmarkUser.create!(
       name: "Benchmark User", 
       email: "test-#{Thread.current.object_id}@example.com"
     )
@@ -20,10 +20,10 @@ RailsBenchmarkSuite.register_workload("Active Record Heft", weight: 0.4) do
     
     # 3. Complex Query (Join + Order)
     # Unloading the relation to force execution
-    RailsBenchmarkSuite::Models::User.joins(:posts)
-                .where(users: { id: user.id })
-                .where("posts.views >= ?", 0)
-                .order("posts.created_at DESC")
+    RailsBenchmarkSuite::Dummy::BenchmarkUser.joins(:posts)
+                .where(benchmark_users: { id: user.id })
+                .where("benchmark_posts.views >= ?", 0)
+                .order("benchmark_posts.created_at DESC")
                 .to_a
     
     # 4. Update

data/lib/rails_benchmark_suite/workloads/cache_heft_workload.rb

@@ -4,7 +4,7 @@ require "active_support/cache"
 require "securerandom"
 
 # Benchmark Workload
-RailsBenchmarkSuite.register_workload("Cache Heft", weight: 0.1) do
+RailsBenchmarkSuite::Runner.register_workload("Cache Heft", weight: 0.1) do
   # Simulate SolidCache using MemoryStore
   @cache ||= ActiveSupport::Cache::MemoryStore.new
   

data/lib/rails_benchmark_suite/workloads/image_heft_workload.rb

@@ -11,7 +11,7 @@ begin
   SAMPLE_IMAGE = File.join(ASSET_DIR, "sample.jpg")
 
   # Only register if vips is actually available
-  RailsBenchmarkSuite.register_workload("Image Heft", weight: 0.1) do
+  RailsBenchmarkSuite::Runner.register_workload("Image Heft", weight: 0.1) do
     # Gracefully handle missing dependencies
     if File.exist?(SAMPLE_IMAGE)
       ImageProcessing::Vips
@@ -26,5 +26,5 @@ begin
 
 rescue LoadError, StandardError
   # Don't register the workload at all if vips is unavailable
-  puts "⚠️  Skipping Image Workload: libvips not available. Install with: 'brew install vips' (macOS) or 'sudo apt install libvips-dev' (Linux)"
+  puts "\n⚠️  Skipping Image Workload: libvips not available. Install with: 'brew install vips' (macOS) or 'sudo apt install libvips-dev' (Linux)\n\n"
 end

data/lib/rails_benchmark_suite/workloads/job_heft_workload.rb

@@ -4,12 +4,12 @@ require "active_record"
 require "json"
 
 
-RailsBenchmarkSuite.register_workload("Solid Queue Heft", weight: 0.2) do
+RailsBenchmarkSuite::Runner.register_workload("Solid Queue Heft", weight: 0.2) do
   # Simulation: Enqueue 100 jobs, then work them off
   
   # 1. Enqueue Loop
   100.times do |i|
-    RailsBenchmarkSuite::Models::SimulatedJob.create!(
+    RailsBenchmarkSuite::Dummy::BenchmarkJob.create!(
       queue_name: "default", 
       arguments: { job_id: i, payload: "x" * 100 }.to_json,
       scheduled_at: Time.now
@@ -23,12 +23,12 @@ RailsBenchmarkSuite.register_workload("Solid Queue Heft", weight: 0.2) do
     # Transactional polling
     ActiveRecord::Base.transaction do
       # Fetch batch
-      jobs = RailsBenchmarkSuite::Models::SimulatedJob.where("scheduled_at <= ?", Time.now).order(:created_at).limit(10)
+      jobs = RailsBenchmarkSuite::Dummy::BenchmarkJob.where("scheduled_at <= ?", Time.now).order(:created_at).limit(10)
       
       if jobs.any?
         # Simulate processing time and delete
         ids = jobs.map(&:id)
-        RailsBenchmarkSuite::Models::SimulatedJob.where(id: ids).delete_all
+        RailsBenchmarkSuite::Dummy::BenchmarkJob.where(id: ids).delete_all
         processed = true
       end
     end

data/lib/rails_benchmark_suite/workloads/view_heft_workload.rb

@@ -6,39 +6,31 @@ require "ostruct"
 # Benchmark Workload
 
 
-# Helper for the workload
+# Helper for the workload - Mixed into ActionView::Base instance automatically by Rails usually, 
+# but here we might need to include it or just rely on standard helpers if ActionView loads them.
+# The template uses number_with_delimiter which is standard.
 module RailsBenchmarkSuiteNumberHelper
-  def self.number_with_delimiter(number)
-    number.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
-  end
+  # No-op or keep provided helper if standard library fails in isolation
 end
 
-  RailsBenchmarkSuite.register_workload("View Heft", weight: 0.2) do
+  RailsBenchmarkSuite::Runner.register_workload("View Heft", weight: 0.2) do
     # Setup context once
     @view_renderer ||= begin
-      lookup_context = ActionView::LookupContext.new([File.expand_path(__dir__)])
+      # Use the "Dummy" app views folder
+      views_path = File.expand_path("../../dummy/app/views", __dir__)
+      lookup_context = ActionView::LookupContext.new([views_path])
       ActionView::Base.with_empty_template_cache.new(lookup_context, {}, nil)
     end
   
-    # Workload: Render a complex ERB template
-    template = <<~ERB
-    <h1>Dashboard for <%= user.name %></h1>
-    <ul>
-      <% posts.each do |post| %>
-        <li>
-          <strong><%= post.title %></strong>
-          <p><%= post.body.truncate(50) %></p>
-          <small>Views: <%= RailsBenchmarkSuiteNumberHelper.number_with_delimiter(post.views) %></small>
-        </li>
-      <% end %>
-    </ul>
-    <footer>Generated at <%= Time.now.to_s %></footer>
-  ERB
+    # Workload: Render template from file
+    # Previously inline, now isolated in lib/dummy/app/views
+
   
   # Dummy Objects
   user = OpenStruct.new(name: "Speedy")
   posts = 100.times.map { |i| OpenStruct.new(title: "Post #{i}", body: "Content " * 10, views: i * 1000) }
 
   # Execution
-  @view_renderer.render(inline: template, locals: { user: user, posts: posts })
+  # Render the namespaced template 'rails_benchmark_suite/heft_view'
+  @view_renderer.render(template: "rails_benchmark_suite/heft_view", locals: { user: user, posts: posts })
 end

data/lib/rails_benchmark_suite.rb

@@ -1,30 +1,8 @@
-# frozen_string_literal: true
-
-require "concurrent"
 require "rails_benchmark_suite/version"
-require "rails_benchmark_suite/reporter"
-require "rails_benchmark_suite/database_manager"
-require "rails_benchmark_suite/workload_runner"
-require "rails_benchmark_suite/formatter"
 require "rails_benchmark_suite/runner"
-require "rails_benchmark_suite/db_setup"
-require "rails_benchmark_suite/schema"
-require "rails_benchmark_suite/models/user"
-require "rails_benchmark_suite/models/post"
-require "rails_benchmark_suite/models/simulated_job"
+require "rails_benchmark_suite/reporter"
+require "rails_benchmark_suite/configuration"
 
 module RailsBenchmarkSuite
-  @workloads = []
-
-  def self.register_workload(name, weight: 1.0, &block)
-    @workloads << { name: name, weight: weight, block: block }
-  end
-
-  def self.run(json: false)
-    # Load workloads
-    Dir[File.join(__dir__, "rails_benchmark_suite", "workloads", "*.rb")].each { |f| require f }
-    
-    runner = Runner.new(@workloads, json: json)
-    runner.run
-  end
+  class Error < StandardError; end
 end