serialbench 0.1.1 → 0.1.2

data/lib/serialbench/benchmark_runner.rb

@@ -3,6 +3,7 @@
 require 'benchmark'
 require 'benchmark/ips'
 require_relative 'serializers'
+require_relative 'models/benchmark_result'
 
 begin
   require 'memory_profiler'
@@ -12,16 +13,14 @@ end
 
 module Serialbench
   class BenchmarkRunner
-    attr_reader :serializers, :test_data, :results, :formats
-
-    def initialize(formats: FORMATS, iterations: nil, warmup: nil, **options)
-      @formats = Array(formats)
-      @options = options
-      @options[:iterations] = iterations if iterations
-      @options[:warmup] = warmup if warmup
-      @serializers = load_available_serializers
+    attr_reader :environment_config, :benchmark_config, :serializers, :test_data, :results
+
+    def initialize(benchmark_config:, environment_config:)
+      @environment_config = environment_config
+      @benchmark_config = benchmark_config
+      @serializers = Serializers.available
       @test_data = {}
-      @results = {}
+      @results = []
       load_test_data
     end
 
@@ -29,201 +28,113 @@ module Serialbench
       puts 'Serialbench - Running comprehensive serialization performance tests'
       puts '=' * 70
       puts "Available serializers: #{@serializers.map(&:name).join(', ')}"
-      puts "Test formats: #{@formats.join(', ')}"
+      puts "Test formats: #{@benchmark_config.formats.join(', ')}"
       puts "Test data sizes: #{@test_data.keys.join(', ')}"
       puts
 
-      @results = {
-        environment: collect_environment_info,
+      Models::BenchmarkResult.new(
+        serializers: Serializers.information,
         parsing: run_parsing_benchmarks,
         generation: run_generation_benchmarks,
-        memory_usage: run_memory_benchmarks
-      }
-
-      # Add streaming benchmarks if any serializers support it
-      streaming_serializers = @serializers.select(&:supports_streaming?)
-      @results[:streaming] = run_streaming_benchmarks if streaming_serializers.any?
-
-      @results
-    end
-
-    def environment_info
-      collect_environment_info
+        memory_usage: run_memory_benchmarks,
+        streaming: run_streaming_benchmarks
+      )
     end
 
     def run_parsing_benchmarks
-      puts 'Running parsing benchmarks...'
-      results = {}
-
-      @test_data.each do |size, format_data|
-        puts "  Testing #{size} files..."
-        results[size] = {}
-
-        format_data.each do |format, data|
-          next unless @formats.include?(format)
-
-          results[size][format] = {}
-          iterations = get_iterations_for_size(size)
-
-          serializers_for_format(format).each do |serializer|
-            next unless serializer.available?
-
-            begin
-              # Warmup
-              3.times { serializer.parse(data) }
-
-              # Benchmark
-              time = Benchmark.realtime do
-                iterations.times { serializer.parse(data) }
-              end
-
-              results[size][format][serializer.name] = {
-                time_per_iterations: time,
-                time_per_iteration: time / iterations.to_f,
-                iterations_per_second: iterations.to_f / time,
-                iterations_count: iterations
-              }
-
-              puts "    #{format}/#{serializer.name}: #{(time / iterations.to_f * 1000).round(2)}ms per parse"
-            rescue StandardError => e
-              puts "    #{format}/#{serializer.name}: ERROR - #{e.message}"
-              results[size][format][serializer.name] = { error: e.message }
-            end
-          end
-        end
+      run_benchmark_type('parsing', 'parse') do |serializer, data|
+        serializer.parse(data)
       end
-
-      results
     end
 
     def run_generation_benchmarks
-      puts "\nRunning generation benchmarks..."
-      results = {}
-
-      @test_data.each do |size, format_data|
-        puts "  Testing #{size} files..."
-        results[size] = {}
-
-        format_data.each do |format, data|
-          next unless @formats.include?(format)
-
-          results[size][format] = {}
-          iterations = get_iterations_for_size(size)
+      run_benchmark_type('generation', 'generation') do |serializer, data|
+        document = serializer.parse(data)
+        serializer.generate(document)
+      end
+    end
 
-          serializers_for_format(format).each do |serializer|
-            next unless serializer.available?
+    def run_streaming_benchmarks
+      run_benchmark_type('streaming', 'stream parse') do |serializer, data|
+        serializer.stream_parse(data) { |event, data| }
+      end
+    end
 
-            begin
-              # Parse document first to get object for generation
-              document = serializer.parse(data)
-
-              # Warmup
-              3.times { serializer.generate(document) }
-
-              # Benchmark
-              time = Benchmark.realtime do
-                iterations.times { serializer.generate(document) }
-              end
-
-              results[size][format][serializer.name] = {
-                time_per_iterations: time,
-                time_per_iteration: time / iterations.to_f,
-                iterations_per_second: iterations.to_f / time,
-                iterations_count: iterations
-              }
+    def run_memory_benchmarks
+      puts "\nRunning memory usage benchmarks..."
+      return [] unless defined?(::MemoryProfiler)
 
-              puts "    #{format}/#{serializer.name}: #{(time / iterations.to_f * 1000).round(2)}ms per generation"
-            rescue StandardError => e
-              puts "    #{format}/#{serializer.name}: ERROR - #{e.message}"
-              results[size][format][serializer.name] = { error: e.message }
-            end
-          end
+      run_benchmark_iteration('memory') do |serializer, format, size, data|
+        # Memory profiling for parsing
+        report = ::MemoryProfiler.report do
+          10.times { serializer.parse(data) }
         end
-      end
 
-      results
+        result = Models::MemoryPerformance.new(
+          adapter: serializer.name,
+          format: format,
+          data_size: size,
+          total_allocated: report.total_allocated,
+          total_retained: report.total_retained,
+          allocated_memory: report.total_allocated_memsize,
+          retained_memory: report.total_retained_memsize
+        )
+
+        puts "    #{format}/#{serializer.name}: #{(report.total_allocated_memsize / 1024.0 / 1024.0).round(2)}MB allocated"
+        result
+      end
     end
 
-    def run_streaming_benchmarks
-      puts "\nRunning streaming benchmarks..."
-      results = {}
-
-      @test_data.each do |size, format_data|
-        puts "  Testing #{size} files..."
-        results[size] = {}
-
-        format_data.each do |format, data|
-          next unless @formats.include?(format)
+    private
 
-          results[size][format] = {}
-          iterations = get_iterations_for_size(size)
+    def run_benchmark_type(type_name, operation_name, &block)
+      puts "#{type_name == 'parsing' ? '' : "\n"}Running #{type_name} benchmarks..."
 
-          serializers_for_format(format).select(&:supports_streaming?).each do |serializer|
-            next unless serializer.available?
+      run_benchmark_iteration(type_name) do |serializer, format, size, data|
+        iterations = get_iterations_for_size(size)
 
-            begin
-              # Warmup
-              3.times { serializer.stream_parse(data) { |event, data| } }
-
-              # Benchmark
-              time = Benchmark.realtime do
-                iterations.times { serializer.stream_parse(data) { |event, data| } }
-              end
-
-              results[size][format][serializer.name] = {
-                time_per_iterations: time,
-                time_per_iteration: time / iterations.to_f,
-                iterations_per_second: iterations.to_f / time,
-                iterations_count: iterations
-              }
+        # Warmup
+        3.times { block.call(serializer, data) }
 
-              puts "    #{format}/#{serializer.name}: #{(time / iterations.to_f * 1000).round(2)}ms per stream parse"
-            rescue StandardError => e
-              puts "    #{format}/#{serializer.name}: ERROR - #{e.message}"
-              results[size][format][serializer.name] = { error: e.message }
-            end
-          end
+        # Benchmark
+        time = Benchmark.realtime do
+          iterations.times { block.call(serializer, data) }
         end
-      end
 
-      results
+        result = Models::IterationPerformance.new(
+          adapter: serializer.name,
+          format: format,
+          data_size: size,
+          time_per_iterations: time,
+          time_per_iteration: time / iterations.to_f,
+          iterations_per_second: iterations.to_f / time,
+          iterations_count: iterations
+        )
+
+        puts "    #{result.format}/#{result.adapter}: #{(result.time_per_iteration * 1000).round(2)}ms per #{operation_name}"
+        result
+      end
     end
 
-    def run_memory_benchmarks
-      puts "\nRunning memory usage benchmarks..."
-      results = {}
-
-      return results unless defined?(::MemoryProfiler)
+    def run_benchmark_iteration(type_name)
+      results = []
 
       @test_data.each do |size, format_data|
         puts "  Testing #{size} files..."
-        results[size] = {}
 
         format_data.each do |format, data|
-          next unless @formats.include?(format)
+          next unless @benchmark_config.formats.include?(format)
 
-          results[size][format] = {}
+          serializers = get_serializers_for_benchmark_type(type_name, format)
 
-          serializers_for_format(format).each do |serializer|
+          serializers.each do |serializer|
             next unless serializer.available?
 
             begin
-              # Memory profiling for parsing
-              report = ::MemoryProfiler.report do
-                10.times { serializer.parse(data) }
-              end
-
-              results[size][format][serializer.name] = {
-                total_allocated: report.total_allocated,
-                total_retained: report.total_retained,
-                allocated_memory: report.total_allocated_memsize,
-                retained_memory: report.total_retained_memsize
-              }
-
-              puts "    #{format}/#{serializer.name}: #{(report.total_allocated_memsize / 1024.0 / 1024.0).round(2)}MB allocated"
+              result = yield(serializer, format, size, data)
+              results << result if result
             rescue StandardError => e
               puts "    #{format}/#{serializer.name}: ERROR - #{e.message}"
-              results[size][format][serializer.name] = { error: e.message }
             end
           end
         end
@@ -232,105 +143,160 @@ module Serialbench
       results
     end
 
-    def serializers_for_format(format)
-      @serializers.select { |s| s.format == format.to_sym }
-    end
-
-    def all_serializers
-      @serializers
-    end
-
-    private
+    def get_serializers_for_benchmark_type(type_name, format)
+      serializers = Serializers.for_format(format)
 
-    def get_iterations_for_size(size)
-      case size
-      when :small
-        20
-      when :medium
-        5
-      when :large
-        2
+      case type_name
+      when 'generation'
+        serializers.select(&:supports_generation?)
+      when 'streaming'
+        serializers.select(&:supports_streaming?)
       else
-        10
+        serializers
       end
     end
 
-    def load_available_serializers
-      Serializers.available.map(&:new)
+    def get_iterations_for_size(size)
+      @benchmark_config.iterations.send(size.to_s)
     end
 
     def load_test_data
-      # Load test data for each format
-      @test_data = {
-        small: {},
-        medium: {},
-        large: {}
-      }
+      # Determine which data sizes to load based on configuration
+      data_sizes = @benchmark_config.data_sizes
 
-      # Generate data for each format
-      @formats.each do |format|
-        case format
-        when :xml
-          @test_data[:small][:xml] = generate_small_xml
-          @test_data[:medium][:xml] = generate_medium_xml
-          @test_data[:large][:xml] = generate_large_xml
-        when :json
-          @test_data[:small][:json] = generate_small_json
-          @test_data[:medium][:json] = generate_medium_json
-          @test_data[:large][:json] = generate_large_json
-        when :yaml
-          @test_data[:small][:yaml] = generate_small_yaml
-          @test_data[:medium][:yaml] = generate_medium_yaml
-          @test_data[:large][:yaml] = generate_large_yaml
-        when :toml
-          @test_data[:small][:toml] = generate_small_toml
-          @test_data[:medium][:toml] = generate_medium_toml
-          @test_data[:large][:toml] = generate_large_toml
+      # Initialize test data structure
+      @test_data = {}
+      data_sizes.each { |size| @test_data[size] = {} }
+
+      # Generate data for each format and size
+      @benchmark_config.formats.each do |format|
+        data_sizes.each do |size|
+          @test_data[size][format] = generate_test_data(format, size)
         end
       end
 
       # Try to load real test files if they exist
-      %w[small medium large].each do |size|
-        @formats.each do |format|
+      data_sizes.each do |size|
+        @benchmark_config.formats.each do |format|
           file_path = "test_data/#{size}.#{format}"
-          @test_data[size.to_sym][format] = File.read(file_path) if File.exist?(file_path)
+          @test_data[size][format] = File.read(file_path) if File.exist?(file_path)
         end
       end
     end
 
+    def generate_test_data(format, size)
+      method_name = "generate_#{size}_#{format}"
+      send(method_name)
+    end
+
+    # Shared data structure generators
+    def small_test_data_structure
+      {
+        config: {
+          database: {
+            host: 'localhost',
+            port: 5432,
+            name: 'myapp',
+            user: 'admin',
+            password: 'secret'
+          },
+          cache: {
+            enabled: true,
+            ttl: 3600
+          }
+        }
+      }
+    end
+
+    def medium_test_data_structure
+      {
+        users: (1..1000).map do |i|
+          {
+            id: i,
+            name: "User #{i}",
+            email: "user#{i}@example.com",
+            created_at: "2023-01-#{(i % 28) + 1}T10:00:00Z",
+            profile: {
+              age: 20 + (i % 50),
+              city: "City #{i % 100}",
+              preferences: {
+                theme: i.even? ? 'dark' : 'light',
+                notifications: i % 3 == 0
+              }
+            }
+          }
+        end
+      }
+    end
+
+    def large_test_data_structure
+      {
+        dataset: {
+          header: {
+            created: '2023-01-01T00:00:00Z',
+            count: 10_000,
+            format: 'data'
+          },
+          records: (1..10_000).map do |i|
+            {
+              id: i,
+              timestamp: "2023-01-01T#{format('%02d', i % 24)}:#{format('%02d', i % 60)}:#{format('%02d', i % 60)}Z",
+              data: {
+                field1: "Value #{i}",
+                field2: i * 2,
+                field3: i % 100 == 0 ? 'special' : 'normal',
+                nested: [
+                  "Item #{i}-1",
+                  "Item #{i}-2",
+                  "Item #{i}-3"
+                ]
+              },
+              metadata: {
+                source: 'generator',
+                version: '1.0',
+                checksum: i.to_s(16)
+              }
+            }
+          end
+        }
+      }
+    end
+
     # XML test data generators
     def generate_small_xml
+      data = small_test_data_structure
       <<~XML
         <?xml version="1.0" encoding="UTF-8"?>
         <config>
           <database>
-            <host>localhost</host>
-            <port>5432</port>
-            <name>myapp</name>
-            <user>admin</user>
-            <password>secret</password>
+            <host>#{data[:config][:database][:host]}</host>
+            <port>#{data[:config][:database][:port]}</port>
+            <name>#{data[:config][:database][:name]}</name>
+            <user>#{data[:config][:database][:user]}</user>
+            <password>#{data[:config][:database][:password]}</password>
           </database>
           <cache>
-            <enabled>true</enabled>
-            <ttl>3600</ttl>
+            <enabled>#{data[:config][:cache][:enabled]}</enabled>
+            <ttl>#{data[:config][:cache][:ttl]}</ttl>
           </cache>
         </config>
       XML
     end
 
     def generate_medium_xml
-      users = (1..1000).map do |i|
+      data = medium_test_data_structure
+      users = data[:users].map do |user|
         <<~USER
-          <user id="#{i}">
-            <name>User #{i}</name>
-            <email>user#{i}@example.com</email>
-            <created_at>2023-01-#{(i % 28) + 1}T10:00:00Z</created_at>
+          <user id="#{user[:id]}">
+            <name>#{user[:name]}</name>
+            <email>#{user[:email]}</email>
+            <created_at>#{user[:created_at]}</created_at>
             <profile>
-              <age>#{20 + (i % 50)}</age>
-              <city>City #{i % 100}</city>
+              <age>#{user[:profile][:age]}</age>
+              <city>#{user[:profile][:city]}</city>
               <preferences>
-                <theme>#{i.even? ? 'dark' : 'light'}</theme>
-                <notifications>#{i % 3 == 0 ? 'true' : 'false'}</notifications>
+                <theme>#{user[:profile][:preferences][:theme]}</theme>
+                <notifications>#{user[:profile][:preferences][:notifications]}</notifications>
               </preferences>
             </profile>
           </user>
@@ -346,26 +312,26 @@ module Serialbench
     end
 
     def generate_large_xml
-      records = (1..10_000).map do |i|
+      data = large_test_data_structure
+      records = data[:dataset][:records].map do |record|
+        nested_items = record[:data][:nested].map { |item| "    <item>#{item}</item>" }.join("\n")
         <<~RECORD
-          <record id="#{i}">
-            <timestamp>2023-01-01T#{format('%02d', i % 24)}:#{format('%02d', i % 60)}:#{format('%02d', i % 60)}Z</timestamp>
-            <data>
-              <field1>Value #{i}</field1>
-              <field2>#{i * 2}</field2>
-              <field3>#{i % 100 == 0 ? 'special' : 'normal'}</field3>
-              <nested>
-                <item>Item #{i}-1</item>
-                <item>Item #{i}-2</item>
-                <item>Item #{i}-3</item>
-              </nested>
-            </data>
-            <metadata>
-              <source>generator</source>
-              <version>1.0</version>
-              <checksum>#{i.to_s(16)}</checksum>
-            </metadata>
-          </record>
+            <record id="#{record[:id]}">
+              <timestamp>#{record[:timestamp]}</timestamp>
+              <data>
+                <field1>#{record[:data][:field1]}</field1>
+                <field2>#{record[:data][:field2]}</field2>
+                <field3>#{record[:data][:field3]}</field3>
+                <nested>
+          #{nested_items}
+                </nested>
+              </data>
+              <metadata>
+                <source>#{record[:metadata][:source]}</source>
+                <version>#{record[:metadata][:version]}</version>
+                <checksum>#{record[:metadata][:checksum]}</checksum>
+              </metadata>
+            </record>
         RECORD
       end.join
 
@@ -373,8 +339,8 @@ module Serialbench
         <?xml version="1.0" encoding="UTF-8"?>
         <dataset>
           <header>
-            <created>2023-01-01T00:00:00Z</created>
-            <count>10000</count>
+            <created>#{data[:dataset][:header][:created]}</created>
+            <count>#{data[:dataset][:header][:count]}</count>
             <format>xml</format>
           </header>
           <records>
@@ -386,215 +352,96 @@ module Serialbench
 
     # JSON test data generators
     def generate_small_json
-      require 'json'
-      JSON.generate({
-                      config: {
-                        database: {
-                          host: 'localhost',
-                          port: 5432,
-                          name: 'myapp',
-                          user: 'admin',
-                          password: 'secret'
-                        },
-                        cache: {
-                          enabled: true,
-                          ttl: 3600
-                        }
-                      }
-                    })
+      JSON.generate(small_test_data_structure)
     end
 
     def generate_medium_json
-      require 'json'
-      users = (1..1000).map do |i|
-        {
-          id: i,
-          name: "User #{i}",
-          email: "user#{i}@example.com",
-          created_at: "2023-01-#{(i % 28) + 1}T10:00:00Z",
-          profile: {
-            age: 20 + (i % 50),
-            city: "City #{i % 100}",
-            preferences: {
-              theme: i.even? ? 'dark' : 'light',
-              notifications: i % 3 == 0
-            }
-          }
-        }
-      end
-
-      JSON.generate({ users: users })
+      JSON.generate(medium_test_data_structure)
     end
 
     def generate_large_json
-      require 'json'
-      records = (1..10_000).map do |i|
-        {
-          id: i,
-          timestamp: "2023-01-01T#{format('%02d', i % 24)}:#{format('%02d', i % 60)}:#{format('%02d', i % 60)}Z",
-          data: {
-            field1: "Value #{i}",
-            field2: i * 2,
-            field3: i % 100 == 0 ? 'special' : 'normal',
-            nested: [
-              "Item #{i}-1",
-              "Item #{i}-2",
-              "Item #{i}-3"
-            ]
-          },
-          metadata: {
-            source: 'generator',
-            version: '1.0',
-            checksum: i.to_s(16)
-          }
-        }
-      end
-
-      JSON.generate({
-                      dataset: {
-                        header: {
-                          created: '2023-01-01T00:00:00Z',
-                          count: 10_000,
-                          format: 'json'
-                        },
-                        records: records
-                      }
-                    })
+      data = large_test_data_structure
+      data[:dataset][:header][:format] = 'json'
+      JSON.generate(data)
     end
 
     # YAML test data generators
     def generate_small_yaml
-      require 'yaml'
-      {
-        config: {
-          database: {
-            host: 'localhost',
-            port: 5432,
-            name: 'myapp',
-            user: 'admin',
-            password: 'secret'
-          },
-          cache: {
-            enabled: true,
-            ttl: 3600
-          }
-        }
-      }.to_yaml
+      small_test_data_structure.to_yaml
     end
 
     def generate_medium_yaml
-      require 'yaml'
-      users = (1..1000).map do |i|
-        {
-          id: i,
-          name: "User #{i}",
-          email: "user#{i}@example.com",
-          created_at: "2023-01-#{(i % 28) + 1}T10:00:00Z",
-          profile: {
-            age: 20 + (i % 50),
-            city: "City #{i % 100}",
-            preferences: {
-              theme: i.even? ? 'dark' : 'light',
-              notifications: i % 3 == 0
-            }
-          }
-        }
-      end
-
-      { users: users }.to_yaml
+      medium_test_data_structure.to_yaml
     end
 
     def generate_large_yaml
-      require 'yaml'
-      records = (1..10_000).map do |i|
-        {
-          id: i,
-          timestamp: "2023-01-01T#{format('%02d', i % 24)}:#{format('%02d', i % 60)}:#{format('%02d', i % 60)}Z",
-          data: {
-            field1: "Value #{i}",
-            field2: i * 2,
-            field3: i % 100 == 0 ? 'special' : 'normal',
-            nested: [
-              "Item #{i}-1",
-              "Item #{i}-2",
-              "Item #{i}-3"
-            ]
-          },
-          metadata: {
-            source: 'generator',
-            version: '1.0',
-            checksum: i.to_s(16)
-          }
-        }
-      end
-
-      {
-        dataset: {
-          header: {
-            created: '2023-01-01T00:00:00Z',
-            count: 10_000,
-            format: 'yaml'
-          },
-          records: records
-        }
-      }.to_yaml
+      data = large_test_data_structure
+      data[:dataset][:header][:format] = 'yaml'
+      data.to_yaml
     end
 
     # TOML test data generators
     def generate_small_toml
+      data = small_test_data_structure
       <<~TOML
         [config]
 
         [config.database]
-        host = "localhost"
-        port = 5432
-        name = "myapp"
-        user = "admin"
-        password = "secret"
+        host = "#{data[:config][:database][:host]}"
+        port = #{data[:config][:database][:port]}
+        name = "#{data[:config][:database][:name]}"
+        user = "#{data[:config][:database][:user]}"
+        password = "#{data[:config][:database][:password]}"
 
         [config.cache]
-        enabled = true
-        ttl = 3600
+        enabled = #{data[:config][:cache][:enabled]}
+        ttl = #{data[:config][:cache][:ttl]}
       TOML
     end
 
     def generate_medium_toml
-      (1..100).map do |i| # Smaller for TOML due to verbosity
+      data = medium_test_data_structure
+      # Use smaller dataset for TOML due to verbosity
+      users = data[:users].first(100)
+      users.map do |user|
         <<~USER
           [[users]]
-          id = #{i}
-          name = "User #{i}"
-          email = "user#{i}@example.com"
-          created_at = "2023-01-#{(i % 28) + 1}T10:00:00Z"
+          id = #{user[:id]}
+          name = "#{user[:name]}"
+          email = "#{user[:email]}"
+          created_at = "#{user[:created_at]}"
 
           [users.profile]
-          age = #{20 + (i % 50)}
-          city = "City #{i % 100}"
+          age = #{user[:profile][:age]}
+          city = "#{user[:profile][:city]}"
 
           [users.profile.preferences]
-          theme = "#{i.even? ? 'dark' : 'light'}"
-          notifications = #{i % 3 == 0}
+          theme = "#{user[:profile][:preferences][:theme]}"
+          notifications = #{user[:profile][:preferences][:notifications]}
         USER
       end.join("\n")
     end
 
     def generate_large_toml
-      records_toml = (1..1000).map do |i| # Smaller for TOML due to verbosity
+      data = large_test_data_structure
+      # Use smaller dataset for TOML due to verbosity
+      records = data[:dataset][:records].first(1000)
+      records_toml = records.map do |record|
         <<~RECORD
           [[dataset.records]]
-          id = #{i}
-          timestamp = "2023-01-01T#{format('%02d', i % 24)}:#{format('%02d', i % 60)}:#{format('%02d', i % 60)}Z"
+          id = #{record[:id]}
+          timestamp = "#{record[:timestamp]}"
 
           [dataset.records.data]
-          field1 = "Value #{i}"
-          field2 = #{i * 2}
-          field3 = "#{i % 100 == 0 ? 'special' : 'normal'}"
-          nested = ["Item #{i}-1", "Item #{i}-2", "Item #{i}-3"]
+          field1 = "#{record[:data][:field1]}"
+          field2 = #{record[:data][:field2]}
+          field3 = "#{record[:data][:field3]}"
+          nested = #{record[:data][:nested].inspect}
 
           [dataset.records.metadata]
-          source = "generator"
-          version = "1.0"
-          checksum = "#{i.to_s(16)}"
+          source = "#{record[:metadata][:source]}"
+          version = "#{record[:metadata][:version]}"
+          checksum = "#{record[:metadata][:checksum]}"
         RECORD
       end.join("\n")
 
@@ -602,21 +449,12 @@ module Serialbench
         [dataset]
 
         [dataset.header]
-        created = "2023-01-01T00:00:00Z"
-        count = 1000
+        created = "#{data[:dataset][:header][:created]}"
+        count = #{records.length}
         format = "toml"
 
         #{records_toml}
       TOML
     end
-
-    def collect_environment_info
-      {
-        ruby_version: RUBY_VERSION,
-        ruby_platform: RUBY_PLATFORM,
-        serializer_versions: @serializers.map { |s| [s.name, s.version] }.to_h,
-        timestamp: Time.now.iso8601
-      }
-    end
   end
 end