rails_benchmark_suite 0.2.9 → 0.3.1

data/lib/rails_benchmark_suite/reporter.rb

@@ -1,15 +1,28 @@
 # frozen_string_literal: true
 
+require "json"
+require "tty-table"
+require "tty-box"
+require "pastel"
+require "tty-cursor"
+
 module RailsBenchmarkSuite
   module Reporter
     module_function
 
+    def pastel
+      @pastel ||= Pastel.new
+    end
+
+    def cursor
+      @cursor ||= TTY::Cursor
+    end
+
     def system_info
       {
         ruby_version: RUBY_VERSION,
         platform: RUBY_PLATFORM,
-        processors: Concurrent.processor_count,
-        libvips: libvips?,
+        processors: defined?(Etc) ? Etc.nprocessors : Concurrent.processor_count,
         yjit: yjit_enabled?
       }
     end
@@ -18,9 +31,206 @@ module RailsBenchmarkSuite
       defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
     end
 
-    def libvips?
-      # Naive check for libvips presence
-      system("vips --version", out: File::NULL, err: File::NULL)
+    def header(info)
+      print cursor.hide
+      # Build YJIT Status
+      yjit_status = info[:yjit] ? pastel.green("ON") : pastel.red("OFF")
+      yjit_hint = info[:yjit] ? "" : " (use RUBY_OPT=\"--yjit\")"
+      
+      content = [
+        "System: #{info[:processors]} Cores | Ruby #{info[:ruby_version]}",
+        "DB: #{info[:db_mode] || 'SQLite (Memory)'} | YJIT: #{yjit_status}#{yjit_hint}"
+      ].join("\n")
+
+      print TTY::Box.frame(
+        width: 80, 
+        title: { top_left: " Rails Benchmark Suite v#{RailsBenchmarkSuite::VERSION} " },
+        padding: 1,
+        style: {
+          fg: :white,
+          border: { fg: :bright_blue }
+        }
+      ) { content }
+      puts ""
+    end
+
+    def render(payload)
+      results = payload[:results]
+      total_score = payload[:total_score]
+      tier = payload[:tier]
+      threads = payload[:threads] || 4
+      
+      puts ""
+      
+      # 1. Comparison Table
+      rows = results.map do |data|
+        report = data[:report]
+        entries = report.entries
+        
+        entry_1t = entries.find { |e| e.label.include?("(1 thread)") }
+        entry_mt = 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_mt / (ips_1t * threads)) * 100 if ips_1t > 0 && threads > 0
+        efficiency ||= 0
+        
+        # Color coding
+        eff_color = if efficiency >= 75
+          :green
+        elsif efficiency >= 50
+          :yellow
+        else
+          :red
+        end
+        
+        # Colorize scaling (Simple heuristic per user request)
+        scale_str = "%.2fx" % scaling
+        if scaling >= 1.0
+          scale_str = pastel.green(scale_str)
+        else
+          scale_str = pastel.red(scale_str)
+        end
+
+        [
+          data[:name],
+          humanize(ips_1t),
+          humanize(ips_mt),
+          scale_str,
+          pastel.decorate("#{efficiency.round(1)}%", eff_color),
+          data[:adjusted_weight].round(2)
+        ]
+      end
+
+      table = TTY::Table.new(
+        header: ["Workload", "1T IPS", "MaxT IPS", "Scaling", "Efficiency", "Weight"], 
+        rows: rows
+      )
+      
+      puts table.render(:unicode, padding: [0, 1]) do |renderer|
+        renderer.border.separator = :each_row
+        renderer.border.style = :blue
+      end
+      
+      # 2. Insights List
+      puts ""
+      check_scaling_insights(results)
+      check_yjit_insight
+      check_memory_insights(results)
+      
+      # 3. Final Score Dashboard
+      render_final_score(total_score)
+      show_hardware_tier(tier)
+    end
+
+    def check_scaling_insights(results)
+      poor_scaling = results.select do |r|
+        entries = r[:report].entries
+        entry_1t = entries.find { |e| e.label.include?("(1 thread)") }
+        entry_mt = 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
+        scaling < 0.8
+      end
+      
+      if poor_scaling.any?
+        puts pastel.yellow.bold("💡 Insight (Scaling):") + " Scaling below 1.0x detected."
+        puts "   This indicates SQLite lock contention or Ruby GIL saturation."
+      end
+    end
+
+    def check_yjit_insight
+      unless yjit_enabled?
+        puts ""
+        puts pastel.yellow.bold("💡 Insight (YJIT):") + " YJIT is OFF."
+        puts "   Run with RUBY_OPT=\"--yjit\" for ~20% boost."
+      end
+    end
+
+    def check_memory_insights(results)
+      results.select { |r| r[:memory_delta_mb] > 20 }.each do |r|
+        puts ""
+        puts pastel.yellow.bold("💡 Insight (Memory):") + " High growth in #{r[:name]} (#{r[:memory_delta_mb].round(1)}MB)"
+        puts "   Suggests heavy object allocation."
+      end
+    end
+
+    def show_hardware_tier(tier)
+      comparison = case tier
+      when "Entry/Dev"
+        "Entry-Level (Suitable for dev/testing)"
+      when "Production-Ready"
+        "Professional-Grade (Matches dedicated instances)"
+      else
+        "High-Performance (Bare-metal speed)"
+      end
+      
+      puts ""
+      puts pastel.bold("📊 Performance Tier: ") + comparison
+      puts ""
+      print cursor.show
+    end
+
+    def render_final_score(score)
+      score_str = "#{score.round(0)}"
+      puts ""
+      
+      print TTY::Box.frame(
+        width: 40,
+        height: 5,
+        align: :center,
+        padding: 1,
+        title: { top_left: " RAILS HEFT INDEX " },
+        style: { border: { fg: :green }, fg: :green }
+      ) {
+        pastel.bold(score_str)
+      }
+    end
+
+    def as_json(payload)
+      out = {
+        system: system_info,
+        total_score: payload[:total_score].round(0),
+        tier: payload[:tier],
+        workloads: []
+      }
+      
+      payload[:results].each do |data|
+        entries = data[:report].entries
+        entry_1t = entries.find { |e| e.label.include?("(1 thread)") }
+        entry_mt = entries.find { |e| e.label.match?(/\(\d+ threads\)/) }
+        
+        ips_1t = entry_1t ? entry_1t.ips : 0
+        ips_mt = entry_mt ? entry_mt.ips : 0
+        
+        out[:workloads] << {
+          name: data[:name],
+          adjusted_weight: data[:adjusted_weight],
+          ips_1t: ips_1t,
+          ips_mt: ips_mt,
+          threads: payload[:threads],
+          scaling: ips_1t > 0 ? (ips_mt / ips_1t) : 0,
+          efficiency: data[:efficiency],
+          memory_delta_mb: data[:memory_delta_mb]
+        }
+      end
+      
+      puts out.to_json
+    end
+
+    def humanize(ips)
+      return "0" if ips.nil? || ips == 0
+      if ips >= 1_000_000
+        "#{(ips / 1_000_000.0).round(1)}M"
+      elsif ips >= 1_000
+        "#{(ips / 1_000.0).round(1)}k"
+      else
+        ips.round(1).to_s
+      end
     end
   end
 end

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,211 +1,66 @@
-# frozen_string_literal: true
-
-require "benchmark/ips"
-require "get_process_mem"
+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(suites, json: false)
-      @suites = suites
-      @json_output = json
-    end
+    # Registry for workloads
+    @workloads = []
 
-    def register(name, &block)
-      @suites << { name: name, block: block }
+    def self.register_workload(name, weight: 1.0, &block)
+      @workloads << { name: name, weight: weight, block: block }
     end
 
-    SETUP_MUTEX = Mutex.new
-
-    def run
-      # Ultimate Hardening: Massive pool and timeout for zero lock contention (v0.2.9)
-      ActiveRecord::Base.establish_connection(
-        adapter: "sqlite3",
-        database: "file:heft_db?mode=memory&cache=shared",
-        pool: 50,
-        timeout: 30000
-      )
-
-      # The 'Busy Timeout' Hammer - force it directly on the raw connection
-      ActiveRecord::Base.connection.raw_connection.busy_timeout = 10000
-      
-      # Setup Schema once safely with Mutex
-      SETUP_MUTEX.synchronize do
-        # Verify if schema already loaded by checking for a table
-        unless ActiveRecord::Base.connection.table_exists?(:users)
-          RailsBenchmarkSuite::Schema.load
-        end
-      end
-
-      # High-Performance Pragmas for WAL + NORMAL sync
-      ActiveRecord::Base.connection.raw_connection.execute("PRAGMA journal_mode = WAL")
-      ActiveRecord::Base.connection.raw_connection.execute("PRAGMA synchronous = NORMAL")
-      ActiveRecord::Base.connection.raw_connection.execute("PRAGMA mmap_size = 268435456") # 256MB - reduce disk I/O
-
-      puts "Running RailsBenchmarkSuite Benchmarks..." unless @json_output
-      puts system_report unless @json_output
-      puts "\n" unless @json_output
-
-      results = {}
-
-      @suites.each do |suite|
-        puts "== Running Suite: #{suite[:name]} ==" unless @json_output
-        
-        # Capture memory before
-        mem_before = GetProcessMem.new.mb
-
-        # Run benchmark
-        report = Benchmark.ips do |x|
-          x.config(:time => 5, :warmup => 2)
-          
-          # Single Threaded
-          x.report("#{suite[:name]} (1 thread)") do
-            with_retries { suite[:block].call }
-          end
-
-          # Multi Threaded (4 threads)
-          x.report("#{suite[:name]} (4 threads)") do
-            threads = 4.times.map do
-              Thread.new do
-                # Ensure each thread gets a dedicated connection
-                ActiveRecord::Base.connection_pool.with_connection do
-                  with_retries { suite[:block].call }
-                end
-              end
-            end
-            threads.each(&:join)
-          end
-
-          x.compare!
-        end
-
-        # Capture memory after
-        mem_after = GetProcessMem.new.mb
-        
-        results[suite[:name]] = {
-          report: report,
-          memory_delta_mb: mem_after - mem_before,
-          weight: suite[:weight]
-        }
-        
-        puts "Memory Footprint: #{mem_after.round(2)} MB (+#{(mem_after - mem_before).round(2)} MB)" unless @json_output
-        puts "\n" unless @json_output
-      end
-      
-      print_summary(results)
-      results
+    def initialize(config)
+      @config = config
     end
 
-    private
-
-    def with_retries
-      yield
-    rescue ActiveRecord::StatementInvalid => e
-      if e.message =~ /locked/i
-        # Specifically drop the lock for THIS connection only
-        ActiveRecord::Base.connection.reset!
-        sleep(rand(0.01..0.05))
-        retry
-      else
-        raise e
-      end
-    end
-
-    def system_report
-      info = RailsBenchmarkSuite::Reporter.system_info
-      yjit_status = if defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
-        "Enabled"
-      else
-        "Disabled (Requires Ruby with YJIT support for best results)"
-      end
-      "System: Ruby #{info[:ruby_version]} (#{info[:platform]}), #{info[:processors]} Cores. YJIT: #{yjit_status}. Libvips: #{info[:libvips]}"
-    end
-
-    def print_summary(results)
-      if @json_output
-        print_json(results)
-        return
+    def run
+      # 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
 
-      puts "\n"
-      puts "=========================================================================================="
-      puts "| %-25s | %-25s | %-12s | %-15s |" % ["Suite", "IPS (1t / 4t)", "Scaling", "Mem Delta"]
-      puts "=========================================================================================="
+      # 1. Setup Database
+      DatabaseManager.new.setup(use_local_db: @config.db)
       
-      total_score = 0
-      
-      results.each do |name, data|
-        report = data[:report]
-        entries = report.entries
-        
-        entry_1t = entries.find { |e| e.label.include?("(1 thread)") }
-        entry_4t = entries.find { |e| e.label.include?("(4 threads)") }
-        
-        ips_1t = entry_1t ? entry_1t.ips : 0
-        ips_4t = entry_4t ? entry_4t.ips : 0
-        
-        scaling = ips_1t > 0 ? (ips_4t / ips_1t) : 0
-        mem = data[:memory_delta_mb]
-        
-        # Heft Score: Weighted Sum of 4t IPS
-        weight = data[:weight] || 1.0
-        weighted_score = ips_4t * weight
-        total_score += weighted_score
-        
-        puts "| %-25s | %-25s | x%-11.2f | +%-14.2fMB |" % [
-          name + " (w: #{weight})", 
-          "#{humanize(ips_1t)} / #{humanize(ips_4t)}",
-          scaling, 
-          mem
-        ]
-      end
-      puts "=========================================================================================="
-      puts "\n"
-      puts "  >>> FINAL HEFT SCORE: #{total_score.round(0)} <<<"
-      puts "\n"
-    end
-
-    def print_json(results)
-      require "json"
+      # 2. Display Header
+      header_info = Reporter.system_info.merge(
+        threads: @config.threads,
+        db_mode: @config.db_mode
+      )
+      Reporter.header(header_info) unless @config.json
       
-      out = {
-        system: RailsBenchmarkSuite::Reporter.system_info,
-        total_score: 0,
-        suites: []
+      # 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
       }
       
-      total_score = 0
+      payload = WorkloadRunner.new(
+        Runner.instance_variable_get(:@workloads), 
+        options: runner_options,
+        show_progress: !@config.json
+      ).execute
       
-      results.each do |name, data|
-        weight = data[:weight] || 1.0
-        
-        # Parse reports
-        ips_1t = data[:report].entries.find { |e| e.label.include?("(1 thread)") }&.ips || 0
-        ips_4t = data[:report].entries.find { |e| e.label.include?("(4 threads)") }&.ips || 0
-        
-        weighted_score = ips_4t * weight
-        total_score += weighted_score
-        
-        out[:suites] << {
-          name: name,
-          weight: weight,
-          ips_1t: ips_1t,
-          ips_4t: ips_4t,
-          scaling: ips_1t > 0 ? (ips_4t / ips_1t) : 0,
-          memory_delta_mb: data[:memory_delta_mb],
-          score: weighted_score
-        }
+      # 4. Report Results
+      if @config.json
+        Reporter.as_json(payload)
+      else
+        Reporter.render(payload)
       end
-      
-      out[:total_score] = total_score.round(0)
-      puts out.to_json
-    end
 
-    def humanize(ips)
-      return "0" if ips.nil?
-      if ips > 1000
-        "%.1fk" % (ips / 1000.0)
-      else
-        "%.1f" % ips
+      # 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