serialbench 0.1.1 → 0.1.2

data/lib/serialbench/ruby_build_manager.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'yaml'
+require 'fileutils'
+
+module Serialbench
+  # Manages Ruby-Build definitions from the official ruby-build repository
+  class RubyBuildManager
+    GITHUB_API_URL = 'https://api.github.com/repos/rbenv/ruby-build/contents/share/ruby-build'
+    CACHE_DIR = File.expand_path('~/.serialbench')
+    CACHE_FILE = File.join(CACHE_DIR, 'ruby-build-definitions.yaml')
+
+    class << self
+      def update_definitions
+        puts '🔄 Fetching Ruby-Build definitions from GitHub...'
+
+        definitions = fetch_definitions_from_github
+        save_definitions_to_cache(definitions)
+
+        puts "✅ Updated #{definitions.length} Ruby-Build definitions"
+        puts "📁 Cache location: #{CACHE_FILE}"
+
+        definitions
+      rescue StandardError => e
+        raise "Failed to update Ruby-Build definitions: #{e.message}"
+      end
+
+      def list_definitions
+        load_definitions_from_cache
+      end
+
+      def show_definition(tag)
+        definitions = load_definitions_from_cache
+
+        unless definitions.include?(tag)
+          raise "Ruby-Build definition '#{tag}' not found. Available definitions: #{definitions.length}"
+        end
+
+        {
+          tag: tag,
+          available: true,
+          source: 'ruby-build',
+          cache_file: CACHE_FILE
+        }
+      end
+
+      def validate_tag(tag)
+        puts "🔍 Validating Ruby-Build tag: #{tag} against #{CACHE_FILE}"
+        return false if tag.nil? || tag.strip.empty?
+
+        definitions = load_definitions_from_cache
+        definitions.include?(tag)
+      rescue StandardError
+        false
+      end
+
+      def suggest_current_ruby_tag
+        ruby_version = RUBY_VERSION
+
+        # Try exact match first
+        return ruby_version if validate_tag(ruby_version)
+
+        # Try common variations
+        variations = [
+          ruby_version,
+          "#{ruby_version}.0",
+          ruby_version.split('.')[0..1].join('.') + '.0'
+        ]
+
+        variations.each do |variation|
+          return variation if validate_tag(variation)
+        end
+
+        # Return the Ruby version even if not found, user can adjust
+        ruby_version
+      end
+
+      def cache_exists?
+        File.exist?(CACHE_FILE)
+      end
+
+      def cache_age
+        return nil unless cache_exists?
+
+        Time.now - File.mtime(CACHE_FILE)
+      end
+
+      def ensure_cache_exists!
+        return if cache_exists?
+
+        raise <<~ERROR
+          Ruby-Build definitions cache not found.
+
+          Update the cache first:
+            serialbench ruby-build update
+        ERROR
+      end
+
+      private
+
+      def fetch_definitions_from_github
+        uri = URI(GITHUB_API_URL)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        request = Net::HTTP::Get.new(uri)
+        request['Accept'] = 'application/vnd.github.v3+json'
+        request['User-Agent'] = 'Serialbench Ruby-Build Manager'
+
+        response = http.request(request)
+
+        raise "GitHub API request failed: #{response.code} #{response.message}" unless response.code == '200'
+
+        data = JSON.parse(response.body)
+
+        # Extract definition names from the file list
+        definitions = data
+                      .select { |item| item['type'] == 'file' }
+                      .map { |item| item['name'] }
+                      .sort
+
+        raise 'No Ruby-Build definitions found in GitHub response' if definitions.empty?
+
+        definitions
+      end
+
+      def save_definitions_to_cache(definitions)
+        FileUtils.mkdir_p(CACHE_DIR)
+
+        cache_data = {
+          'updated_at' => Time.now.utc.iso8601,
+          'source' => GITHUB_API_URL,
+          'count' => definitions.length,
+          'definitions' => definitions
+        }
+
+        File.write(CACHE_FILE, cache_data.to_yaml)
+      end
+
+      def load_definitions_from_cache
+        ensure_cache_exists!
+
+        cache_data = YAML.load_file(CACHE_FILE)
+        cache_data['definitions'] || []
+      rescue StandardError => e
+        raise "Failed to load Ruby-Build definitions from cache: #{e.message}"
+      end
+    end
+  end
+end

data/lib/serialbench/runners/asdf_runner.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'yaml'
+require 'open3'
+require 'stringio'
+require_relative '../benchmark_runner'
+require_relative 'base'
+
+module Serialbench
+  # Handles ASDF-based benchmark execution
+  module Runners
+    class AsdfRunner < Base
+      class AsdfError < StandardError; end
+
+      def initialize(environment_config, environment_config_path)
+        super
+        validate_asdf_available
+      end
+
+      # Prepare Ruby versions via ASDF
+      def prepare
+        puts '💎 Preparing Ruby versions via ASDF...'
+
+        ruby_version = @environment_config.ruby_build_tag
+        installed_versions = get_installed_ruby_versions
+
+        unless installed_versions.include?(ruby_version)
+          if @environment_config.asdf&.auto_install
+            install_missing_versions([ruby_version])
+          else
+            raise AsdfError,
+                  "Missing Ruby version: #{ruby_version}. Set auto_install: true to install automatically."
+          end
+        end
+
+        # Install gems for the Ruby version
+        install_gems_for_version(ruby_version)
+
+        puts '✅ Ruby version is prepared with gems installed'
+      end
+
+      # Run benchmark
+      def benchmark
+        puts '🚀 Running benchmarks...'
+
+        ruby_version = @environment_config.ruby_build_tag
+
+        raise AsdfError, 'Benchmark run failed' unless run_benchmark(ruby_version)
+
+        puts '✅ Completed 1 benchmark runs'
+        puts "📁 Individual results are available in: results/runs/#{@environment_name}"
+        puts '✅ ASDF benchmark completed successfully!'
+        puts "Results saved to: results/runs/#{@environment_name}"
+        puts "Generate site: serialbench benchmark build-site results/runs/#{@environment_name}"
+      end
+
+      private
+
+      # Validate ASDF is available
+      def validate_asdf_available
+        unless system('asdf --version > /dev/null 2>&1')
+          raise AsdfError,
+                'ASDF is not installed or not available in PATH'
+        end
+
+        # Check if ruby plugin is installed
+        return if system('asdf plugin list | grep -q ruby')
+
+        raise AsdfError, 'ASDF ruby plugin is not installed. Run: asdf plugin add ruby'
+      end
+
+      # Get list of installed Ruby versions
+      def get_installed_ruby_versions
+        output = `asdf list ruby 2>/dev/null`.strip
+        return [] if output.empty?
+
+        output.split("\n").map(&:strip).reject(&:empty?).map do |line|
+          # Remove leading asterisk and whitespace
+          line.gsub(/^\*?\s*/, '')
+        end
+      end
+
+      # Install missing Ruby versions
+      def install_missing_versions(versions)
+        puts "📦 Installing missing Ruby versions: #{versions.join(', ')}"
+
+        versions.each do |version|
+          puts "🔨 Installing Ruby #{version}..."
+
+          # Create temporary log directory
+          Dir.mktmpdir('asdf_install_ruby') do |temp_log_dir|
+            # Create a temporary file for logging
+            install_log = File.join(temp_log_dir, "install-ruby-#{version}.log")
+
+            success = false
+            Dir.chdir(temp_log_dir) do
+              success = system("asdf install ruby #{version} > #{install_log} 2>&1")
+            end
+
+            if success
+              puts "✅ Installed Ruby #{version}"
+            else
+              puts "❌ Failed to install Ruby #{version} (see #{install_log})"
+              raise AsdfError, "Failed to install Ruby #{version}"
+            end
+          end
+        end
+      end
+
+      # Install gems for a specific Ruby version
+      def install_gems_for_version(ruby_version)
+        puts "🔧 Installing gems for Ruby #{ruby_version}..."
+
+        # Create temporary log directory
+        temp_log_dir = "results/asdf-#{ruby_version}"
+        FileUtils.mkdir_p(temp_log_dir)
+        gem_install_log = File.join(temp_log_dir, "gems-ruby-#{ruby_version}.log")
+
+        # Use ASDF to install bundler and the serialbench gem
+        puts "   📦 Installing bundler and serialbench for Ruby #{ruby_version}..."
+        env = { 'ASDF_RUBY_VERSION' => ruby_version }
+        cmd = ['asdf', 'exec', 'gem', 'install', 'bundler', 'serialbench', '--no-document']
+
+        success = system(env, *cmd, out: gem_install_log, err: gem_install_log)
+        unless success
+          puts "❌ Failed to install gems for Ruby #{ruby_version} (see #{gem_install_log})"
+          raise AsdfError, "Failed to install gems for Ruby #{ruby_version}"
+        end
+
+        # ASDF doesn't need reshash like rbenv - gems are immediately available
+        puts "✅ Gems installed for Ruby #{ruby_version}"
+      end
+
+      # Run benchmark for specific Ruby version
+      def run_benchmark(benchmark_config, benchmark_config_path, result_dir)
+        puts "🚀 Running benchmark for #{@name}..."
+
+        FileUtils.mkdir_p(result_dir)
+
+        prepare
+
+        ruby_version = @environment_config.ruby_build_tag
+        puts "🏃 Running benchmarks for Ruby #{ruby_version}..."
+        puts "   📁 Results will be saved to: #{result_dir}"
+
+        benchmark_log = File.join(result_dir, 'benchmark.log')
+
+        # Run benchmark directly using BenchmarkRunner instead of CLI
+        puts '   🚀 Starting benchmark execution...'
+
+        # Set ASDF Ruby version for this process
+        ENV['ASDF_RUBY_VERSION'] = ruby_version
+
+        # Capture stdout/stderr for logging
+        log_output = StringIO.new
+
+        runner = Serialbench::BenchmarkRunner.new(
+          benchmark_config: benchmark_config,
+          environment_config: @environment_config
+        )
+
+        # Run benchmarks and capture output
+        puts "   Running benchmarks with #{benchmark_config.iterations} iterations..."
+
+        # Redirect stdout to capture benchmark output
+        original_stdout = $stdout
+        $stdout = log_output
+
+        results = runner.run_all_benchmarks
+
+        # Restore stdout
+        $stdout = original_stdout
+
+        # Save benchmark results to results.yaml
+        results_file = File.join(result_dir, 'results.yaml')
+
+        # Create platform string
+        require_relative 'models/platform'
+        platform = Serialbench::Models::Platform.current_local
+        platform_string = "asdf-#{platform.os}-#{platform.arch}-ruby-#{ruby_version}"
+
+        # Create comprehensive results structure with platform and metadata merged in
+        full_results = {
+          'platform' => {
+            'platform_string' => platform_string,
+            'type' => 'asdf',
+            'os' => platform.os,
+            'arch' => platform.arch
+          },
+          'metadata' => {
+            'environment_name' => @environment_name,
+            'benchmark_config' => @benchmark_config,
+            'created_at' => Time.now.iso8601,
+            'tags' => ['asdf', platform.os, platform.arch, "ruby-#{ruby_version}"]
+          },
+          'environment' => {
+            'name' => @environment_name,
+            'type' => 'asdf',
+            'ruby_build_tag' => ruby_version,
+            'created_at' => Time.now.iso8601
+          },
+          'config' => {
+            'benchmark_config' => @benchmark_config,
+            'formats' => config['formats'],
+            'iterations' => config['iterations'],
+            'data_sizes' => config['data_sizes']
+          },
+          'results' => results
+        }
+
+        File.write(results_file, full_results.to_yaml)
+
+        # Save execution log
+        File.write(benchmark_log, log_output.string)
+
+        puts "✅ Completed Ruby #{ruby_version}"
+        puts "   Results saved to: #{results_file}"
+        puts "   Log saved to: #{benchmark_log}"
+        true
+      rescue StandardError => e
+        puts "❌ Failed Ruby #{ruby_version}: #{e.message}"
+        File.write(benchmark_log, "Error: #{e.message}\n#{e.backtrace.join("\n")}")
+        false
+      ensure
+        # Clean up environment variable and restore stdout
+        ENV.delete('ASDF_RUBY_VERSION')
+        $stdout = original_stdout if defined?(original_stdout)
+      end
+
+      # Process and merge results
+      def process_results(successful_runs)
+        puts "📊 Processing #{successful_runs} successful results..."
+
+        # Find all result directories with valid results
+        # Look for directories that contain results/runs subdirectories
+        result_dirs = Dir.glob(File.join(@output_dir, 'asdf-*')).select do |dir|
+          results_runs_dir = File.join(dir, 'results', 'runs')
+          Dir.exist?(results_runs_dir) && !Dir.glob(File.join(results_runs_dir, '*')).empty?
+        end
+
+        if result_dirs.empty?
+          puts '⚠️  No results found for processing, but benchmarks completed successfully!'
+          puts "📁 Individual results are available in: #{@output_dir}"
+          return
+        end
+
+        puts '🎉 Results processed successfully!'
+        puts "📁 Results directory: #{@output_dir}"
+        puts '📊 Individual benchmark results available in:'
+        result_dirs.each do |dir|
+          puts "   - #{dir}"
+        end
+        puts ''
+        puts '💡 To create a comparison report, use:'
+        puts '   serialbench resultset new multi-ruby-comparison'
+        result_dirs.each do |dir|
+          result_name = File.basename(dir)
+          puts "   serialbench resultset add-result multi-ruby-comparison #{result_name}"
+        end
+        puts '   serialbench resultset build-site multi-ruby-comparison'
+      end
+
+      # Generate combined platform string for directory naming
+      # Format: asdf-{os}-{arch}-ruby-{version}
+      def generate_platform_string(runner_type, ruby_version)
+        # Get OS name
+        os = case RUBY_PLATFORM
+             when /darwin/
+               'macos'
+             when /linux/
+               'linux'
+             when /mswin|mingw|cygwin/
+               'windows'
+             else
+               'unknown'
+             end
+
+        # Get architecture (simplified)
+        arch = case RUBY_PLATFORM
+               when /x86_64|amd64/
+                 'x64'
+               when /arm64|aarch64/
+                 'arm64'
+               when /i386|i686/
+                 'x86'
+               else
+                 'unknown'
+               end
+
+        "#{runner_type}-#{os}-#{arch}-ruby-#{ruby_version}"
+      end
+    end
+  end
+end

data/lib/serialbench/runners/base.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'yaml'
+require 'open3'
+require 'stringio'
+
+module Serialbench
+  # Handles ASDF-based benchmark execution
+  module Runners
+    class Base
+      def initialize(environment_config, environment_config_path)
+        @environment_config = environment_config
+        @environment_config_path = environment_config_path
+
+        raise 'environment_config is required' unless @environment_config
+        raise 'environment_config_path is required' unless @environment_config_path
+        raise 'environment_config_path must be a valid file' unless File.exist?(@environment_config_path)
+      end
+
+      def prepare
+        raise NotImplementedError, 'Subclasses must implement the prepare method'
+      end
+
+      # Run benchmark
+      def benchmark
+        raise NotImplementedError, 'Subclasses must implement the benchmark method'
+      end
+    end
+  end
+end

data/lib/serialbench/runners/docker_runner.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require_relative '../ruby_build_manager'
+require_relative 'base'
+
+module Serialbench
+  module Runners
+    # Handles Docker-based benchmark execution
+    class DockerRunner < Base
+      class DockerError < StandardError; end
+
+      def initialize(environment_config, environment_config_path)
+        super
+
+        @docker_image = @environment_config.docker&.image
+        raise 'docker.image is required' unless @docker_image
+
+        # Handle dockerfile path relative to environment file
+        dockerfile_path = @environment_config.docker&.dockerfile
+        raise 'docker.dockerfile path is required' unless dockerfile_path
+
+        @dockerfile = Pathname.new(environment_config_path).dirname.join(dockerfile_path).to_s
+        raise "path '#{@dockerfile}' specified in docker.dockerfile is not found" unless File.exist?(@dockerfile)
+
+        validate_docker_available
+      end
+
+      # Build Docker image for this environment
+      def prepare
+        puts "🐳 Preparing Docker image for #{@name}..."
+
+        puts "   🐍 Using Docker image: #{base_image_string}"
+        puts "   🔨 Building Docker image: #{docker_image_string}"
+
+        cmd = [
+          'docker', 'build',
+          '--build-arg', "BASE_IMAGE=#{base_image_string}",
+          '-t', docker_image_string,
+          '-f', @dockerfile,
+          '.'
+        ]
+
+        # Show command being run
+        puts "   🔧 Running command: #{cmd.join(' ')}"
+        success = system(*cmd)
+
+        raise DockerError, "Failed to build Docker image '#{docker_image_string}'" unless success
+
+        puts "✅ Docker image prepared successfully for #{docker_image_string}"
+      end
+
+      def base_image_string
+        @environment_config.docker.image
+      end
+
+      def docker_image_string
+        "serialbench:#{@environment_config.ruby_build_tag}"
+      end
+
+      # Run benchmark for this environment
+      def run_benchmark(benchmark_config, benchmark_config_path, result_dir)
+        puts "🚀 Running benchmark at #{@environment_config_path}..."
+
+        FileUtils.mkdir_p(result_dir)
+
+        # Build image if not already built
+        prepare unless image_exists?
+
+        # Run the benchmark
+        run_benchmark_in_container(benchmark_config, benchmark_config_path, result_dir)
+
+        puts "✅ Benchmark completed for #{@environment_config_path}"
+      end
+
+      private
+
+      # Validate Docker is available
+      def validate_docker_available
+        unless system('docker --version > /dev/null 2>&1')
+          raise DockerError, 'Docker is not installed or not available in PATH'
+        end
+
+        return if system('docker info > /dev/null 2>&1')
+
+        raise DockerError, 'Docker daemon is not running'
+      end
+
+      # Check if Docker image exists
+      def image_exists?
+        image_name = "serialbench:#{@name}"
+        system("docker image inspect #{image_name} > /dev/null 2>&1")
+      end
+
+      # Run benchmark in container
+      def run_benchmark_in_container(benchmark_config, benchmark_config_path, result_dir)
+        puts '🏃 Running benchmark in Docker container...'
+        puts "   📁 Results will be saved to: #{result_dir}"
+        puts "   🐳 Using Docker image: #{docker_image_string}"
+
+        benchmark_log = File.join(result_dir, 'benchmark.log')
+
+        cmd = [
+          'docker', 'run', '--rm',
+          '-v', "#{File.expand_path(result_dir)}:/app/results",
+          '-v', "#{File.expand_path(@environment_config_path)}:/app/environment.yml",
+          '-v', "#{File.expand_path(benchmark_config_path)}:/app/benchmark_config.yml",
+          # TODO: do not hard code this path in the docker image
+          '-v', "#{RubyBuildManager::CACHE_FILE}:/root/.serialbench/ruby-build-definitions.yaml",
+          docker_image_string,
+          'benchmark',
+          '_docker_execute',
+          '--result_dir=/app/results',
+          '/app/environment.yml',
+          '/app/benchmark_config.yml'
+        ]
+
+        puts "   🔧 Running command: #{cmd.join(' ')}"
+        puts "   📝 Benchmark output will be logged to: #{benchmark_log}"
+        puts '   ⏳ This may take several minutes...'
+
+        success = system("#{cmd.join(' ')} > #{benchmark_log} 2>&1")
+        puts "   ✅ Command executed with status: #{success ? 'success' : 'failure'}"
+        puts "   📊 Checking if results saved to: #{File.join(result_dir, 'results.yaml')}"
+
+        if success && File.exist?(File.join(result_dir, 'results.yaml'))
+          puts '✅ Benchmark completed successfully'
+          puts "   📊 Results saved to: #{File.join(result_dir, 'results.yaml')}"
+        else
+          puts "❌ Benchmark failed (see #{benchmark_log})"
+          puts "   🔍 Check log file for details: #{benchmark_log}"
+          if File.exist?(benchmark_log)
+            puts '   📄 Last few lines of log:'
+            system("tail -10 #{benchmark_log} | sed 's/^/      /'")
+          end
+          raise DockerError, 'Benchmark execution failed'
+        end
+      end
+    end
+  end
+end

data/lib/serialbench/serializers/base_serializer.rb

@@ -1,26 +1,20 @@
 # frozen_string_literal: true
 
+require 'singleton'
+
 module Serialbench
   module Serializers
     class BaseSerializer
+      include Singleton
+
       def initialize
         # Override in subclasses
       end
 
-      def available?
-        raise NotImplementedError, 'Subclasses must implement #available?'
-      end
-
-      def name
-        raise NotImplementedError, 'Subclasses must implement #name'
-      end
-
-      def version
-        raise NotImplementedError, 'Subclasses must implement #version'
-      end
-
-      def format
-        raise NotImplementedError, 'Subclasses must implement #format'
+      %w[name version format library_require_name available?].each do |method_name|
+        define_method(method_name) do
+          self.class.send(method_name)
+        end
       end
 
       def parse(data)
@@ -44,8 +38,6 @@ module Serialbench
         false
       end
 
-      protected
-
       def require_library(library_name)
         require library_name
         true

data/lib/serialbench/serializers/json/base_json_serializer.rb

@@ -6,7 +6,7 @@ module Serialbench
   module Serializers
     module Json
       class BaseJsonSerializer < BaseSerializer
-        def format
+        def self.format
           :json
         end
 
@@ -29,7 +29,9 @@ module Serialbench
           }
         end
 
-        protected
+        def supports_generation?
+          true
+        end
 
         def supports_pretty_print?
           true
@@ -48,8 +50,6 @@ module Serialbench
           raise NotImplementedError, 'Subclasses must implement #library_require_name'
         end
 
-        public
-
         # Check if the JSON library is available
         def available?
           return @available if defined?(@available)